Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python

Fix user deletion failing with IntegrityError on NOT NULL foreign keys (#239)

Murtaza Nasirba499d71e216
diff --git a/src/api/admin.py b/src/api/admin.py
index 0c0a8d60..f4e3c0f8 100644
--- a/src/api/admin.py
+++ b/src/api/admin.py
@@ -328,15 +328,21 @@ def admin_delete_user(user_id):
total_chunks = TranscriptChunk.query.filter_by(user_id=user_id).count()
if total_chunks > 0:
current_app.logger.info(f"Deleting {total_chunks} transcript chunks with embeddings for user {user_id}")
-
+
for recording in user.recordings:
try:
if recording.audio_path and os.path.exists(recording.audio_path):
os.remove(recording.audio_path)
except Exception as e:
current_app.logger.error(f"Error deleting audio file {recording.audio_path}: {e}")
-
- # Delete user (cascade will handle all related data including chunks/embeddings)
+
+ # Explicitly delete related records that might not cascade properly
+ ProcessingJob.query.filter_by(user_id=user_id).delete()
+ InternalShare.query.filter(
+ (InternalShare.owner_id == user_id) | (InternalShare.shared_with_user_id == user_id)
+ ).delete()
+
+ # Delete user (cascade will handle remaining related data including chunks/embeddings)
db.session.delete(user)
db.session.commit()
diff --git a/src/models/audit.py b/src/models/audit.py
index beeceddb..283ab87f 100644
--- a/src/models/audit.py
+++ b/src/models/audit.py
@@ -21,7 +21,7 @@ class ShareAuditLog(db.Model):
# Actor (who performed the action)
actor_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
- actor = db.relationship('User', foreign_keys=[actor_id], backref='audit_actions_performed')
+ actor = db.relationship('User', foreign_keys=[actor_id], backref=db.backref('audit_actions_performed', cascade='all, delete-orphan'))
# Target (who was affected - optional for some actions)
target_user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
diff --git a/src/models/organization.py b/src/models/organization.py
index 1e536eda..d20339a5 100644
--- a/src/models/organization.py
+++ b/src/models/organization.py
@@ -47,7 +47,7 @@ class GroupMembership(db.Model):
# Relationships
group = db.relationship('Group', back_populates='memberships')
- user = db.relationship('User', backref=db.backref('group_memberships', lazy=True))
+ user = db.relationship('User', backref=db.backref('group_memberships', lazy=True, cascade='all, delete-orphan'))
# Unique constraint: user can only be in a group once
__table_args__ = (db.UniqueConstraint('group_id', 'user_id', name='unique_group_membership'),)
diff --git a/src/models/processing_job.py b/src/models/processing_job.py
index 375e1cd6..313328c7 100644
--- a/src/models/processing_job.py
+++ b/src/models/processing_job.py
@@ -40,7 +40,7 @@ class ProcessingJob(db.Model):
completed_at = db.Column(db.DateTime, nullable=True)
# Relationships
- user = db.relationship('User', backref=db.backref('processing_jobs', lazy='dynamic'))
+ user = db.relationship('User', backref=db.backref('processing_jobs', lazy='dynamic', cascade='all, delete-orphan'))
recording = db.relationship('Recording', backref=db.backref('processing_jobs', lazy='dynamic', cascade='all, delete-orphan'))
def __repr__(self):
diff --git a/src/models/push_subscription.py b/src/models/push_subscription.py
index d44662dd..222bddd9 100644
--- a/src/models/push_subscription.py
+++ b/src/models/push_subscription.py
@@ -20,6 +20,9 @@ class PushSubscription(db.Model):
p256dh_key = db.Column(db.String(200), nullable=False)
auth_key = db.Column(db.String(100), nullable=False)
+ # Relationships
+ user = db.relationship('User', backref=db.backref('push_subscriptions', lazy=True, cascade='all, delete-orphan'))
+
# Timestamps
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
diff --git a/src/models/sharing.py b/src/models/sharing.py
index 83bf3a62..6929f3f7 100644
--- a/src/models/sharing.py
+++ b/src/models/sharing.py
@@ -69,8 +69,8 @@ class InternalShare(db.Model):
# Relationships
recording = db.relationship('Recording', backref=db.backref('internal_shares', lazy=True, cascade='all, delete-orphan'))
- owner = db.relationship('User', foreign_keys=[owner_id], backref=db.backref('shared_recordings', lazy=True))
- shared_with = db.relationship('User', foreign_keys=[shared_with_user_id], backref=db.backref('received_shares', lazy=True))
+ owner = db.relationship('User', foreign_keys=[owner_id], backref=db.backref('shared_recordings', lazy=True, cascade='all, delete'))
+ shared_with = db.relationship('User', foreign_keys=[shared_with_user_id], backref=db.backref('received_shares', lazy=True, cascade='all, delete'))
# Unique constraint: can't share same recording with same user twice
__table_args__ = (db.UniqueConstraint('recording_id', 'shared_with_user_id', name='unique_recording_share'),)
@@ -216,7 +216,7 @@ class SharedRecordingState(db.Model):
# Relationships
recording = db.relationship('Recording', backref=db.backref('user_states', lazy=True, cascade='all, delete-orphan'))
- user = db.relationship('User', backref=db.backref('recording_states', lazy=True))
+ user = db.relationship('User', backref=db.backref('recording_states', lazy=True, cascade='all, delete-orphan'))
# Unique constraint: one state per user per recording
__table_args__ = (db.UniqueConstraint('recording_id', 'user_id', name='unique_user_recording_state'),)
diff --git a/src/models/token_usage.py b/src/models/token_usage.py
index 0868fff9..cd7461fd 100644
--- a/src/models/token_usage.py
+++ b/src/models/token_usage.py
@@ -33,7 +33,7 @@ class TokenUsage(db.Model):
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
- user = db.relationship('User', backref=db.backref('token_usage', lazy='dynamic'))
+ user = db.relationship('User', backref=db.backref('token_usage', lazy='dynamic', cascade='all, delete-orphan'))
__table_args__ = (
db.UniqueConstraint('user_id', 'date', 'operation_type', name='uq_user_date_op'),
diff --git a/src/models/transcription_usage.py b/src/models/transcription_usage.py
index 6697dc21..271e437d 100644
--- a/src/models/transcription_usage.py
+++ b/src/models/transcription_usage.py
@@ -31,7 +31,7 @@ class TranscriptionUsage(db.Model):
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
- user = db.relationship('User', backref=db.backref('transcription_usage', lazy='dynamic'))
+ user = db.relationship('User', backref=db.backref('transcription_usage', lazy='dynamic', cascade='all, delete-orphan'))
__table_args__ = (
db.UniqueConstraint('user_id', 'date', 'connector_type', name='uq_user_date_connector'),
diff --git a/tests/test_user_cascade_delete.py b/tests/test_user_cascade_delete.py
new file mode 100644
index 00000000..395c2e72
--- /dev/null
+++ b/tests/test_user_cascade_delete.py
@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Tests for user deletion cascade behavior (Issue #239).
+
+Ensures that deleting a user with related records (processing jobs, shares,
+usage tracking, etc.) does not fail with IntegrityError due to missing
+cascade configuration on NOT NULL foreign keys.
+
+Two test strategies:
+1. Runtime introspection: inspect SQLAlchemy relationships on User to verify
+ every NOT NULL FK has cascade delete configured. Catches future models.
+2. Integration: create a user with records in every related table, delete the
+ user, and verify no errors and no orphaned rows.
+
+Run with: python tests/test_user_cascade_delete.py
+"""
+
+import os
+import sys
+import unittest
+from datetime import datetime, date
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.app import app, db
+from src.models import (
+ User, Recording, ProcessingJob, Share, InternalShare, SharedRecordingState,
+ TokenUsage, TranscriptionUsage, GroupMembership, Group, Tag, Folder,
+ Speaker, APIToken, InquireSession, ExportTemplate, TranscriptTemplate,
+ NamingTemplate, TranscriptChunk, PushSubscription, ShareAuditLog,
+)
+
+
+# ---------------------------------------------------------------------------
+# Test 1: Runtime introspection — verify cascade on all NOT NULL User FKs
+# ---------------------------------------------------------------------------
+
+class TestUserRelationshipCascades(unittest.TestCase):
+ """
+ Inspect every SQLAlchemy relationship on the User model. For each
+ one-to-many relationship where the child FK is NOT NULL, verify that
+ cascade includes 'delete'. This catches any new model that forgets to
+ add cascade and would break user deletion.
+ """
+
+ def test_all_not_null_user_fk_relationships_have_cascade_delete(self):
+ from sqlalchemy.orm.relationships import ONETOMANY
+
+ with app.app_context():
+ missing = []
+
+ for name, rel in User.__mapper__.relationships.items():
+ # Only check one-to-many (backrefs from other models to User)
+ if rel.direction != ONETOMANY:
+ continue
+
+ # Check FK columns on the child model
+ for parent_col, child_col in rel.synchronize_pairs:
+ if not child_col.nullable and 'delete' not in rel.cascade:
+ model_name = rel.mapper.class_.__name__
+ missing.append(
+ f"User.{name} -> {model_name}.{child_col.name} "
+ f"(NOT NULL FK without cascade delete)"
+ )
+
+ self.assertEqual(
+ missing, [],
+ "Found User relationships with NOT NULL foreign keys but no cascade "
+ "delete. Deleting a user will fail with IntegrityError.\n"
+ "Fix: add cascade='all, delete-orphan' (or 'all, delete' for multi-parent) "
+ "to the backref:\n" +
+ "\n".join(f" - {m}" for m in missing)
+ )
+
+ def test_user_recordings_relationship_exists(self):
+ """Sanity check that User.recordings is defined (nullable FK, so no cascade needed)."""
+ with app.app_context():
+ self.assertTrue(
+ hasattr(User, 'recordings'),
+ "User model must have a 'recordings' relationship"
+ )
+
+
+# ---------------------------------------------------------------------------
+# Test 2: Integration — create user with related records, then delete
+# ---------------------------------------------------------------------------
+
+class TestUserDeletionIntegration(unittest.TestCase):
+ """
+ Create a user with records in every table that has a FK to user.id,
+ then delete the user and verify it succeeds without IntegrityError.
+ """
+
+ def setUp(self):
+ """Create a fresh user for each test."""
+ self.app_context = app.app_context()
+ self.app_context.push()
+ app.config['WTF_CSRF_ENABLED'] = False
+
+ # Clean up any leftover test user
+ existing = User.query.filter_by(username="cascade_test_user").first()
+ if existing:
+ db.session.delete(existing)
+ db.session.commit()
+
+ self.user = User(
+ username="cascade_test_user",
+ password="fakehash",
+ )
+ db.session.add(self.user)
+ db.session.commit()
+
+ def test_delete_user_with_processing_jobs(self):
+ """Issue #239: ProcessingJob.user_id NOT NULL must cascade."""
+ rec = Recording(user_id=self.user.id, title="test", status="COMPLETED")
+ db.session.add(rec)
+ db.session.flush()
+
+ job = ProcessingJob(
+ user_id=self.user.id,
+ recording_id=rec.id,
+ job_type='transcribe',
+ status='completed',
+ )
+ db.session.add(job)
+ db.session.commit()
+ job_id = job.id
+
+ # This was the exact operation that failed before the fix
+ ProcessingJob.query.filter_by(user_id=self.user.id).delete()
+ db.session.delete(self.user)
+ db.session.commit()
+
+ self.assertIsNone(db.session.get(ProcessingJob, job_id))
+
+ def test_delete_user_with_token_usage(self):
+ """TokenUsage.user_id NOT NULL must cascade."""
+ usage = TokenUsage(
+ user_id=self.user.id,
+ date=date.today(),
+ operation_type='summarize',
+ prompt_tokens=100,
+ completion_tokens=50,
+ )
+ db.session.add(usage)
+ db.session.commit()
+ usage_id = usage.id
+
+ db.session.delete(self.user)
+ db.session.commit()
+
+ self.assertIsNone(db.session.get(TokenUsage, usage_id))
+
+ def test_delete_user_with_transcription_usage(self):
+ """TranscriptionUsage.user_id NOT NULL must cascade."""
+ usage = TranscriptionUsage(
+ user_id=self.user.id,
+ date=date.today(),
+ connector_type='openai_whisper',
+ audio_duration_seconds=120,
+ )
+ db.session.add(usage)
+ db.session.commit()
+ usage_id = usage.id
+
+ db.session.delete(self.user)
+ db.session.commit()
+
+ self.assertIsNone(db.session.get(TranscriptionUsage, usage_id))
+
+ def test_delete_user_with_group_memberships(self):
+ """GroupMembership.user_id NOT NULL must cascade."""
+ group = Group(name="Test Group", description="for cascade test")
+ db.session.add(group)
+ db.session.flush()
+
+ membership = GroupMembership(
+ group_id=group.id,
+ user_id=self.user.id,
+ role='member',
+ )
+ db.session.add(membership)
+ db.session.commit()
+ membership_id = membership.id
+
+ db.session.delete(self.user)
+ db.session.commit()
+
+ self.assertIsNone(db.session.get(GroupMembership, membership_id))
+
+ # Cleanup group
+ db.session.delete(group)
+ db.session.commit()
+
+ def test_delete_user_with_internal_shares(self):
+ """InternalShare has two NOT NULL User FKs (owner + shared_with)."""
+ # Create a second user to be the share recipient
+ other = User(
+ username="cascade_other_user",
+ password="fakehash",
+ )
+ db.session.add(other)
+ db.session.flush()
+
+ rec = Recording(user_id=self.user.id, title="shared rec", status="COMPLETED")
+ db.session.add(rec)
+ db.session.flush()
+
+ share = InternalShare(
+ recording_id=rec.id,
+ owner_id=self.user.id,
+ shared_with_user_id=other.id,
+ )
+ db.session.add(share)
+ db.session.commit()
+ share_id = share.id
+
+ # Delete owner user — share should be removed
+ InternalShare.query.filter(
+ (InternalShare.owner_id == self.user.id) |
+ (InternalShare.shared_with_user_id == self.user.id)
+ ).delete()
+ db.session.delete(self.user)
+ db.session.commit()
+
+ self.assertIsNone(db.session.get(InternalShare, share_id))
+
+ # Cleanup
+ db.session.delete(other)
+ db.session.commit()
+
+ def test_delete_user_with_push_subscriptions(self):
+ """PushSubscription.user_id NOT NULL must cascade."""
+ sub = PushSubscription(
+ user_id=self.user.id,
+ endpoint="https://push.example.com/test-cascade",
+ p256dh_key="fake_p256dh",
+ auth_key="fake_auth",
+ )
+ db.session.add(sub)
+ db.session.commit()
+ sub_id = sub.id
+
+ db.session.delete(self.user)
+ db.session.commit()
+
+ self.assertIsNone(db.session.get(PushSubscription, sub_id))
+
+ def test_admin_delete_user_endpoint(self):
+ """Full integration: call the admin DELETE endpoint with a user that has data."""
+ rec = Recording(user_id=self.user.id, title="admin test", status="COMPLETED")
+ db.session.add(rec)
+ db.session.flush()
+
+ job = ProcessingJob(
+ user_id=self.user.id,
+ recording_id=rec.id,
+ job_type='transcribe',
+ status='completed',
+ )
+ db.session.add(job)
+ db.session.commit()
+ user_id = self.user.id
+
+ # Create an admin user to perform the delete
+ admin = User.query.filter_by(username="cascade_admin").first()
+ if not admin:
+ admin = User(
+ username="cascade_admin",
+ password="fakehash",
+ is_admin=True,
+ )
+ db.session.add(admin)
+ db.session.commit()
+
+ with app.test_client() as client:
+ with client.session_transaction() as sess:
+ sess['_user_id'] = str(admin.id)
+
+ resp = client.delete(f'/admin/users/{user_id}')
+ self.assertEqual(resp.status_code, 200, f"Admin delete failed: {resp.get_json()}")
+ data = resp.get_json()
+ self.assertTrue(data.get('success'), f"Expected success=True, got: {data}")
+
+ # Verify user is gone
+ self.assertIsNone(db.session.get(User, user_id))
+
+ # Mark user as deleted so tearDown doesn't try to clean it up
+ self.user = None
+
+ # Cleanup admin
+ db.session.delete(admin)
+ db.session.commit()
+
+ def tearDown(self):
+ db.session.rollback()
+ # Final cleanup if test failed before deletion
+ if self.user:
+ leftover = db.session.get(User, self.user.id) if self.user.id else None
+ else:
+ leftover = User.query.filter_by(username="cascade_test_user").first()
+ if leftover:
+ ProcessingJob.query.filter_by(user_id=leftover.id).delete()
+ InternalShare.query.filter(
+ (InternalShare.owner_id == leftover.id) |
+ (InternalShare.shared_with_user_id == leftover.id)
+ ).delete()
+ db.session.delete(leftover)
+ db.session.commit()
+ # Also clean up helper users if they exist
+ for uname in ("cascade_other_user", "cascade_admin"):
+ helper = User.query.filter_by(username=uname).first()
+ if helper:
+ db.session.delete(helper)
+ db.session.commit()
+ self.app_context.pop()
+
+
+# ---------------------------------------------------------------------------
+# Runner
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+ unittest.main(verbosity=2)