Throw away flix files in favor of a flix database

crates/db/src/connection.rs

@@ -0,0 +1,22 @@
+//! Types and functions related to [DatabaseConnection]s
+
+use sea_orm::{DatabaseConnection, DbErr};
+use sea_orm_migration::MigratorTrait as _;
+
+/// A newtype wrapping a [DatabaseConnection]
+pub struct Connection(DatabaseConnection);
+
+impl Connection {
+	/// Helper function for apllying database migrations while wrapping a
+	/// [DatabaseConnection] in a newtype
+	pub async fn try_from(database: DatabaseConnection) -> Result<Self, DbErr> {
+		crate::migration::Migrator::up(&database, None).await?;
+		Ok(Self(database))
+	}
+}
+
+impl AsRef<DatabaseConnection> for Connection {
+	fn as_ref(&self) -> &DatabaseConnection {
+		&self.0
+	}
+}

crates/db/src/entity/content/collections.rs

@@ -0,0 +1,66 @@
+//! Collection entity
+
+use flix_model::id::{CollectionId, LibraryId};
+
+use seamantic::model::path::PathBytes;
+
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a collection media folder
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_collections")]
+pub struct Model {
+	/// The collection's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: CollectionId,
+	/// The collection's parent
+	pub parent: Option<CollectionId>,
+	/// The collection's slug
+	pub slug: String,
+	/// The collection's library ID
+	pub library: LibraryId,
+	/// The collection's directory
+	pub directory: PathBytes,
+	/// The collection's poster path
+	pub relative_poster_path: Option<PathBytes>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The parent collection of this collection
+	#[sea_orm(
+		belongs_to = "super::collections::Entity",
+		from = "Column::Parent",
+		to = "super::collections::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Parent,
+	/// The library this collection belongs to
+	#[sea_orm(
+		belongs_to = "super::libraries::Entity",
+		from = "Column::Library",
+		to = "super::libraries::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Library,
+}
+
+impl Related<super::collections::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Parent.def()
+	}
+}
+
+impl Related<super::libraries::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Library.def()
+	}
+}

crates/db/src/entity/content/episodes.rs

@@ -0,0 +1,58 @@
+//! Episode entity
+
+use flix_model::id::{LibraryId, ShowId};
+
+use seamantic::model::path::PathBytes;
+
+use flix_model::numbers::{EpisodeNumber, SeasonNumber};
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a episode media folder
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_episodes")]
+pub struct Model {
+	/// The episode's show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub show: ShowId,
+	/// The episode's season's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub season: SeasonNumber,
+	/// The episode's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub episode: EpisodeNumber,
+	/// The episode's slug
+	pub slug: String,
+	/// The episode's library
+	pub library: LibraryId,
+	/// The episode's directory
+	pub directory: PathBytes,
+	/// The episode's media path
+	pub relative_media_path: PathBytes,
+	/// The episode's poster path
+	pub relative_poster_path: Option<PathBytes>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The library this episode belongs to
+	#[sea_orm(
+		belongs_to = "super::libraries::Entity",
+		from = "Column::Library",
+		to = "super::libraries::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Library,
+}
+
+impl Related<super::libraries::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Library.def()
+	}
+}

crates/db/src/entity/content/libraries.rs

@@ -0,0 +1,73 @@
+//! Library entity
+
+use flix_model::id::LibraryId;
+
+use seamantic::model::path::PathBytes;
+
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a library media folder
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_libraries")]
+pub struct Model {
+	/// The library's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: LibraryId,
+	/// The library's directory
+	pub directory: PathBytes,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// All collections in this library
+	#[sea_orm(has_many = "super::collections::Entity")]
+	Collections,
+	#[sea_orm(has_many = "super::movies::Entity")]
+	/// All movies in this library
+	Movies,
+	#[sea_orm(has_many = "super::shows::Entity")]
+	/// All shows in this library
+	Shows,
+	#[sea_orm(has_many = "super::seasons::Entity")]
+	/// All seasons in this library
+	Seasons,
+	#[sea_orm(has_many = "super::episodes::Entity")]
+	/// All episodes in this library
+	Episodes,
+}
+
+impl Related<super::collections::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Collections.def()
+	}
+}
+
+impl Related<super::movies::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Movies.def()
+	}
+}
+
+impl Related<super::shows::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Shows.def()
+	}
+}
+
+impl Related<super::seasons::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Seasons.def()
+	}
+}
+
+impl Related<super::episodes::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Episodes.def()
+	}
+}

crates/db/src/entity/content/mod.rs

@@ -0,0 +1,340 @@
+//! This module contains entities for storing media file information
+
+pub mod libraries;
+
+pub mod collections;
+
+pub mod movies;
+
+pub mod episodes;
+pub mod seasons;
+pub mod shows;
+
+#[cfg(test)]
+mod tests {
+	use std::path::Path;
+
+	use flix_model::id::{CollectionId, LibraryId, MovieId, ShowId};
+
+	use sea_orm::ActiveModelTrait;
+	use sea_orm::ActiveValue::{NotSet, Set};
+	use sea_orm::sqlx::error::ErrorKind;
+	use sea_orm_migration::MigratorTrait;
+
+	use crate::migration::Migrator;
+	use crate::tests::new_memory_db;
+
+	use super::super::tests::get_error_kind;
+	use super::super::tests::{
+		make_flix_collection, make_flix_episode, make_flix_movie, make_flix_season, make_flix_show,
+	};
+	use super::super::tests::{noneable, notsettable};
+
+	#[tokio::test]
+	async fn test_inserts() {
+		let db = new_memory_db().await;
+		Migrator::up(&db, None).await.expect("up");
+
+		// Libraries
+		macro_rules! assert_library {
+			($db:expr, $id:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_library!(@insert, $db, $id $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, LibraryId::from_raw($id));
+				assert_eq!(model.directory, Path::new(concat!("/L/", $id)).to_owned().into());
+			};
+			($db:expr, $id:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_library!(@insert, $db, $id $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal $(; $($skip:ident),+)?) => {
+				super::libraries::ActiveModel {
+					id: notsettable!(id, LibraryId::from_raw($id) $(, $($skip),+)?),
+					directory: notsettable!(directory, Path::new(concat!("/L/", $id)).to_owned().into() $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_library!(&db, 1, Success);
+		assert_library!(&db, 1, UniqueViolation);
+		assert_library!(&db, 2, Success);
+		assert_library!(&db, 3, Success; id);
+		assert_library!(&db, 4, NotNullViolation; directory);
+
+		// Collections
+		macro_rules! assert_collection {
+			($db:expr, $id:literal, $pid:expr, $lid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_collection!(@insert, $db, $id, $pid, $lid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, CollectionId::from_raw($id));
+				assert_eq!(model.parent, $pid);
+				assert_eq!(model.slug, concat!("C/", $id).to_string());
+				assert_eq!(model.library, LibraryId::from_raw($lid));
+				assert_eq!(model.directory, Path::new(concat!("/C/", $id)).to_owned().into());
+				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, Path::new(concat!("C/Poster", $id)).to_owned().into() $(, $($skip),+)?));
+			};
+			($db:expr, $id:literal, $pid:expr, $lid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_collection!(@insert, $db, $id, $pid, $lid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $pid:expr, $lid:literal $(; $($skip:ident),+)?) => {
+				super::collections::ActiveModel {
+					id: notsettable!(id, CollectionId::from_raw($id) $(, $($skip),+)?),
+					parent: notsettable!(parent, $pid $(, $($skip),+)?),
+					slug: notsettable!(slug, concat!("C/", $id).to_string() $(, $($skip),+)?),
+					library: notsettable!(library, LibraryId::from_raw($lid) $(, $($skip),+)?),
+					directory: notsettable!(directory, Path::new(concat!("/C/", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_poster_path: notsettable!(relative_poster_path, Some(Path::new(concat!("C/Poster", $id)).to_owned().into()) $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_collection!(&db, 1, None, 0, ForeignKeyViolation);
+		assert_collection!(
+			&db,
+			1,
+			Some(CollectionId::from_raw(0)),
+			1,
+			ForeignKeyViolation
+		);
+		assert_collection!(&db, 1, None, 1, ForeignKeyViolation);
+		make_flix_collection!(&db, 1);
+		make_flix_collection!(&db, 2);
+		make_flix_collection!(&db, 3);
+		make_flix_collection!(&db, 4);
+		make_flix_collection!(&db, 8);
+
+		assert_collection!(&db, 1, None, 1, Success);
+		assert_collection!(&db, 1, None, 1, UniqueViolation);
+		assert_collection!(&db, 2, None, 1, Success);
+		assert_collection!(&db, 3, None, 1, Success; id);
+		assert_collection!(&db, 4, None, 1, Success; parent);
+		assert_collection!(&db, 5, None, 1, NotNullViolation; slug);
+		assert_collection!(&db, 6, None, 1, NotNullViolation; library);
+		assert_collection!(&db, 7, None, 1, NotNullViolation; directory);
+		assert_collection!(&db, 8, None, 1, Success; relative_poster_path);
+
+		// Movies
+		macro_rules! assert_movie {
+			($db:expr, $id:literal, $pid:expr, $lid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_movie!(@insert, $db, $id, $pid, $lid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, MovieId::from_raw($id));
+				assert_eq!(model.parent, $pid);
+				assert_eq!(model.slug, concat!("M/", $id).to_string());
+				assert_eq!(model.library, LibraryId::from_raw($lid));
+				assert_eq!(model.directory, Path::new(concat!("/M/", $id)).to_owned().into());
+				assert_eq!(model.relative_media_path, Path::new(concat!("M/Media", $id)).to_owned().into());
+				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, Path::new(concat!("M/Poster", $id)).to_owned().into() $(, $($skip),+)?));
+			};
+			($db:expr, $id:literal, $pid:expr, $lid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_movie!(@insert, $db, $id, $pid, $lid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $pid:expr, $lid:literal $(; $($skip:ident),+)?) => {
+				super::movies::ActiveModel {
+					id: notsettable!(id, MovieId::from_raw($id) $(, $($skip),+)?),
+					parent: notsettable!(parent, $pid $(, $($skip),+)?),
+					slug: notsettable!(slug, concat!("M/", $id).to_string() $(, $($skip),+)?),
+					library: notsettable!(library, LibraryId::from_raw($lid) $(, $($skip),+)?),
+					directory: notsettable!(directory, Path::new(concat!("/M/", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_media_path: notsettable!(relative_media_path, Path::new(concat!("M/Media", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_poster_path: notsettable!(relative_poster_path, Some(Path::new(concat!("M/Poster", $id)).to_owned().into()) $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_movie!(&db, 1, None, 0, ForeignKeyViolation);
+		assert_movie!(
+			&db,
+			1,
+			Some(CollectionId::from_raw(0)),
+			1,
+			ForeignKeyViolation
+		);
+		assert_movie!(&db, 1, None, 1, ForeignKeyViolation);
+		make_flix_movie!(&db, 1);
+		make_flix_movie!(&db, 2);
+		make_flix_movie!(&db, 3);
+		make_flix_movie!(&db, 4);
+		make_flix_movie!(&db, 9);
+
+		assert_movie!(&db, 1, None, 1, Success);
+		assert_movie!(&db, 1, None, 1, UniqueViolation);
+		assert_movie!(&db, 2, None, 1, Success);
+		assert_movie!(&db, 3, None, 1, Success; id);
+		assert_movie!(&db, 4, None, 1, Success; parent);
+		assert_movie!(&db, 5, None, 1, NotNullViolation; slug);
+		assert_movie!(&db, 6, None, 1, NotNullViolation; library);
+		assert_movie!(&db, 7, None, 1, NotNullViolation; directory);
+		assert_movie!(&db, 8, None, 1, NotNullViolation; relative_media_path);
+		assert_movie!(&db, 9, None, 1, Success; relative_poster_path);
+
+		// Shows
+		macro_rules! assert_show {
+			($db:expr, $id:literal, $pid:expr, $lid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_show!(@insert, $db, $id, $pid, $lid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, ShowId::from_raw($id));
+				assert_eq!(model.parent, $pid);
+				assert_eq!(model.slug, concat!("S/", $id).to_string());
+				assert_eq!(model.library, LibraryId::from_raw($lid));
+				assert_eq!(model.directory, Path::new(concat!("/S/", $id)).to_owned().into());
+				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, Path::new(concat!("S/Poster", $id)).to_owned().into() $(, $($skip),+)?));
+			};
+			($db:expr, $id:literal, $pid:expr, $lid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_show!(@insert, $db, $id, $pid, $lid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $pid:expr, $lid:literal $(; $($skip:ident),+)?) => {
+				super::shows::ActiveModel {
+					id: notsettable!(id, ShowId::from_raw($id) $(, $($skip),+)?),
+					parent: notsettable!(parent, $pid $(, $($skip),+)?),
+					slug: notsettable!(slug, concat!("S/", $id).to_string() $(, $($skip),+)?),
+					library: notsettable!(library, LibraryId::from_raw($lid) $(, $($skip),+)?),
+					directory: notsettable!(directory, Path::new(concat!("/S/", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_poster_path: notsettable!(relative_poster_path, Some(Path::new(concat!("S/Poster", $id)).to_owned().into()) $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_show!(&db, 1, None, 0, ForeignKeyViolation);
+		assert_show!(
+			&db,
+			1,
+			Some(CollectionId::from_raw(0)),
+			1,
+			ForeignKeyViolation
+		);
+		assert_show!(&db, 1, None, 1, ForeignKeyViolation);
+		make_flix_show!(&db, 1);
+		make_flix_show!(&db, 2);
+		make_flix_show!(&db, 3);
+		make_flix_show!(&db, 4);
+		make_flix_show!(&db, 8);
+
+		assert_show!(&db, 1, None, 1, Success);
+		assert_show!(&db, 1, None, 1, UniqueViolation);
+		assert_show!(&db, 2, None, 1, Success);
+		assert_show!(&db, 3, None, 1, Success; id);
+		assert_show!(&db, 4, None, 1, Success; parent);
+		assert_show!(&db, 5, None, 1, NotNullViolation; slug);
+		assert_show!(&db, 6, None, 1, NotNullViolation; library);
+		assert_show!(&db, 7, None, 1, NotNullViolation; directory);
+		assert_show!(&db, 8, None, 1, Success; relative_poster_path);
+
+		// Seasons
+		macro_rules! assert_season {
+			($db:expr, $id:literal, $season:literal, $lid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_season!(@insert, $db, $id, $season, $lid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.show, ShowId::from_raw($id));
+				assert_eq!(model.season, $season);
+				assert_eq!(model.slug, concat!("S/S", $id).to_string());
+				assert_eq!(model.library, LibraryId::from_raw($lid));
+				assert_eq!(model.directory, Path::new(concat!("/S/S", $id)).to_owned().into());
+				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, Path::new(concat!("S/S/Poster", $id)).to_owned().into() $(, $($skip),+)?));
+			};
+			($db:expr, $id:literal, $season:literal, $lid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_season!(@insert, $db, $id, $season, $lid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $season:literal, $lid:literal $(; $($skip:ident),+)?) => {
+				super::seasons::ActiveModel {
+					show: notsettable!(id, ShowId::from_raw($id) $(, $($skip),+)?),
+					season: notsettable!(season, $season $(, $($skip),+)?),
+					slug: notsettable!(slug, concat!("S/S", $id).to_string() $(, $($skip),+)?),
+					library: notsettable!(library, LibraryId::from_raw($lid) $(, $($skip),+)?),
+					directory: notsettable!(directory, Path::new(concat!("/S/S", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_poster_path: notsettable!(relative_poster_path, Some(Path::new(concat!("S/S/Poster", $id)).to_owned().into()) $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_season!(&db, 1, 1, 0, ForeignKeyViolation);
+		assert_season!(&db, 1, 1, 1, ForeignKeyViolation);
+		make_flix_season!(&db, 1, 1);
+		make_flix_season!(&db, 1, 2);
+		make_flix_season!(&db, 2, 1);
+		make_flix_season!(&db, 3, 1);
+		make_flix_season!(&db, 8, 1);
+
+		assert_season!(&db, 1, 1, 1, Success);
+		assert_season!(&db, 1, 2, 1, Success);
+		assert_season!(&db, 1, 1, 1, UniqueViolation);
+		assert_season!(&db, 2, 1, 1, Success);
+		assert_season!(&db, 3, 1, 1, Success; show);
+		assert_season!(&db, 4, 1, 1, NotNullViolation; season);
+		assert_season!(&db, 5, 1, 1, NotNullViolation; slug);
+		assert_season!(&db, 6, 1, 1, NotNullViolation; library);
+		assert_season!(&db, 7, 1, 1, NotNullViolation; directory);
+		assert_season!(&db, 8, 1, 1, Success; relative_poster_path);
+
+		// Episodes
+		macro_rules! assert_episode {
+			($db:expr, $id:literal, $season:literal, $episode:literal, $lid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_episode!(@insert, $db, $id, $season, $episode, $lid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.show, ShowId::from_raw($id));
+				assert_eq!(model.season, $season);
+				assert_eq!(model.episode, $episode);
+				assert_eq!(model.slug, concat!("S/S/E", $id).to_string());
+				assert_eq!(model.library, LibraryId::from_raw($lid));
+				assert_eq!(model.directory, Path::new(concat!("/S/S/E", $id)).to_owned().into());
+				assert_eq!(model.relative_media_path, Path::new(concat!("E/Media", $id)).to_owned().into());
+				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, Path::new(concat!("S/S/E/Poster", $id)).to_owned().into() $(, $($skip),+)?));
+			};
+			($db:expr, $id:literal, $season:literal, $episode:literal, $lid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_episode!(@insert, $db, $id, $season, $episode, $lid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $season:literal, $episode:literal, $lid:literal $(; $($skip:ident),+)?) => {
+				super::episodes::ActiveModel {
+					show: notsettable!(id, ShowId::from_raw($id) $(, $($skip),+)?),
+					season: notsettable!(season, $season $(, $($skip),+)?),
+					episode: notsettable!(episode, $episode $(, $($skip),+)?),
+					slug: notsettable!(slug, concat!("S/S/E", $id).to_string() $(, $($skip),+)?),
+					library: notsettable!(library, LibraryId::from_raw($lid) $(, $($skip),+)?),
+					directory: notsettable!(directory, Path::new(concat!("/S/S/E", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_media_path: notsettable!(relative_media_path, Path::new(concat!("E/Media", $id)).to_owned().into() $(, $($skip),+)?),
+					relative_poster_path: notsettable!(relative_poster_path, Some(Path::new(concat!("S/S/E/Poster", $id)).to_owned().into()) $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_episode!(&db, 1, 1, 1, 0, ForeignKeyViolation);
+		assert_episode!(&db, 1, 1, 1, 1, ForeignKeyViolation);
+		make_flix_episode!(&db, 1, 1, 1);
+		make_flix_episode!(&db, 1, 1, 2);
+		make_flix_episode!(&db, 2, 1, 1);
+		make_flix_episode!(&db, 3, 1, 1);
+		make_flix_show!(&db, 10);
+		make_flix_season!(&db, 10, 1);
+		make_flix_episode!(&db, 10, 1, 1);
+
+		assert_episode!(&db, 1, 1, 1, 1, Success);
+		assert_episode!(&db, 1, 1, 2, 1, Success);
+		assert_episode!(&db, 1, 1, 1, 1, UniqueViolation);
+		assert_episode!(&db, 2, 1, 1, 1, Success);
+		assert_episode!(&db, 3, 1, 1, 1, Success; show);
+		assert_episode!(&db, 4, 1, 1, 1, NotNullViolation; season);
+		assert_episode!(&db, 5, 1, 1, 1, NotNullViolation; episode);
+		assert_episode!(&db, 6, 1, 1, 1, NotNullViolation; slug);
+		assert_episode!(&db, 7, 1, 1, 1, NotNullViolation; library);
+		assert_episode!(&db, 8, 1, 1, 1, NotNullViolation; directory);
+		assert_episode!(&db, 9, 1, 1, 1, NotNullViolation; relative_media_path);
+		assert_episode!(&db, 10, 1, 1, 1, Success; relative_poster_path);
+	}
+}

crates/db/src/entity/content/movies.rs

@@ -0,0 +1,68 @@
+//! Movie entity
+
+use flix_model::id::{CollectionId, LibraryId, MovieId};
+
+use seamantic::model::path::PathBytes;
+
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a movie media folder
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_movies")]
+pub struct Model {
+	/// The movie's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: MovieId,
+	/// The movie's parent
+	pub parent: Option<CollectionId>,
+	/// The movie's slug
+	pub slug: String,
+	/// The movie's library
+	pub library: LibraryId,
+	/// The movie's directory
+	pub directory: PathBytes,
+	/// The movie's media path
+	pub relative_media_path: PathBytes,
+	/// The movie's poster path
+	pub relative_poster_path: Option<PathBytes>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The parent collection of this collection
+	#[sea_orm(
+		belongs_to = "super::collections::Entity",
+		from = "Column::Parent",
+		to = "super::collections::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Parent,
+	/// The library this movie belongs to
+	#[sea_orm(
+		belongs_to = "super::libraries::Entity",
+		from = "Column::Library",
+		to = "super::libraries::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Library,
+}
+
+impl Related<super::collections::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Parent.def()
+	}
+}
+
+impl Related<super::libraries::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Library.def()
+	}
+}

crates/db/src/entity/content/seasons.rs

@@ -0,0 +1,53 @@
+//! Season entity
+
+use flix_model::id::{LibraryId, ShowId};
+
+use seamantic::model::path::PathBytes;
+
+use flix_model::numbers::SeasonNumber;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a season media folder
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_seasons")]
+pub struct Model {
+	/// The season's show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub show: ShowId,
+	/// The season's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub season: SeasonNumber,
+	/// The season's slug
+	pub slug: String,
+	/// The season's library
+	pub library: LibraryId,
+	/// The season's directory
+	pub directory: PathBytes,
+	/// The season's poster path
+	pub relative_poster_path: Option<PathBytes>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The library this season belongs to
+	#[sea_orm(
+		belongs_to = "super::libraries::Entity",
+		from = "Column::Library",
+		to = "super::libraries::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Library,
+}
+
+impl Related<super::libraries::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Library.def()
+	}
+}

crates/db/src/entity/content/shows.rs

@@ -0,0 +1,66 @@
+//! Show entity
+
+use flix_model::id::{CollectionId, LibraryId, ShowId};
+
+use seamantic::model::path::PathBytes;
+
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a show media folder
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_shows")]
+pub struct Model {
+	/// The show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: ShowId,
+	/// The show's parent
+	pub parent: Option<CollectionId>,
+	/// The show's slug
+	pub slug: String,
+	/// The show's library
+	pub library: LibraryId,
+	/// The show's directory
+	pub directory: PathBytes,
+	/// The show's poster path
+	pub relative_poster_path: Option<PathBytes>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The parent collection of this collection
+	#[sea_orm(
+		belongs_to = "super::collections::Entity",
+		from = "Column::Parent",
+		to = "super::collections::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Parent,
+	/// The library this show belongs to
+	#[sea_orm(
+		belongs_to = "super::libraries::Entity",
+		from = "Column::Library",
+		to = "super::libraries::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Library,
+}
+
+impl Related<super::collections::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Parent.def()
+	}
+}
+
+impl Related<super::libraries::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Library.def()
+	}
+}

crates/db/src/entity/info/collections.rs

@@ -0,0 +1,27 @@
+//! Collection entity
+
+use flix_model::id::CollectionId;
+
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a flix collection
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_info_collections")]
+pub struct Model {
+	/// The collection's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: CollectionId,
+	/// The collection's title
+	pub title: String,
+	/// The collection's overview
+	pub overview: String,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/info/episodes.rs

@@ -0,0 +1,53 @@
+//! Episode entity
+
+use flix_model::id::ShowId;
+
+use chrono::NaiveDate;
+use flix_model::numbers::{EpisodeNumber, SeasonNumber};
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a flix episode
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_info_episodes")]
+pub struct Model {
+	/// The episode's show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub show: ShowId,
+	/// The episode's season's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub season: SeasonNumber,
+	/// The episode's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub episode: EpisodeNumber,
+	/// The episode's title
+	pub title: String,
+	/// The episode's overview
+	pub overview: String,
+	/// The episode's air date
+	pub date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The show this season belongs to
+	#[sea_orm(
+		belongs_to = "super::shows::Entity",
+		from = "Column::Show",
+		to = "super::shows::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Show,
+}
+
+impl Related<super::shows::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Show.def()
+	}
+}

crates/db/src/entity/info/mod.rs

@@ -0,0 +1,230 @@
+//! This module contains entities for storing media information such as
+//! titles and overviews
+
+pub mod collections;
+
+pub mod movies;
+
+pub mod episodes;
+pub mod seasons;
+pub mod shows;
+
+#[cfg(test)]
+mod tests {
+	use flix_model::id::{CollectionId, MovieId, ShowId};
+
+	use chrono::NaiveDate;
+	use sea_orm::ActiveModelTrait;
+	use sea_orm::ActiveValue::{NotSet, Set};
+	use sea_orm::sqlx::error::ErrorKind;
+	use sea_orm_migration::MigratorTrait;
+
+	use crate::migration::Migrator;
+	use crate::tests::new_memory_db;
+
+	use super::super::tests::get_error_kind;
+	use super::super::tests::notsettable;
+
+	#[tokio::test]
+	async fn test_inserts() {
+		let db = new_memory_db().await;
+		Migrator::up(&db, None).await.expect("up");
+
+		// Collections
+		macro_rules! assert_collection {
+			($db:expr, $id:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_collection!(@insert, $db, $id $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, CollectionId::from_raw($id));
+				assert_eq!(model.title, concat!("C", $id));
+				assert_eq!(model.overview, concat!("Collection", " ", $id));
+			};
+			($db:expr, $id:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_collection!(@insert, $db, $id $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal $(; $($skip:ident),+)?) => {
+				super::collections::ActiveModel {
+					id: notsettable!(id, CollectionId::from_raw($id) $(, $($skip),+)?),
+					title: notsettable!(title, concat!("C", $id).to_string() $(, $($skip),+)?),
+					overview: notsettable!(overview, concat!("Collection", " ", $id).to_string() $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_collection!(&db, 1, Success);
+		assert_collection!(&db, 1, UniqueViolation);
+		assert_collection!(&db, 2, Success);
+		assert_collection!(&db, 3, Success; id);
+		assert_collection!(&db, 4, NotNullViolation; title);
+		assert_collection!(&db, 5, NotNullViolation; overview);
+
+		// Movies
+		macro_rules! assert_movie {
+			($db:expr, $id:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_movie!(@insert, $db, $id $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, MovieId::from_raw($id));
+				assert_eq!(model.title, concat!("M", $id));
+				assert_eq!(model.tagline, concat!("Watch Movie", " ", $id));
+				assert_eq!(model.overview, concat!("Movie", " ", $id));
+				assert_eq!(model.date, NaiveDate::from_yo_opt(2000, $id).expect("NaiveDate::from_yo_opt"));
+			};
+			($db:expr, $id:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_movie!(@insert, $db, $id $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal $(; $($skip:ident),+)?) => {
+				super::movies::ActiveModel {
+					id: notsettable!(id, MovieId::from_raw($id) $(, $($skip),+)?),
+					title: notsettable!(title, concat!("M", $id).to_string() $(, $($skip),+)?),
+					tagline: notsettable!(tagline, concat!("Watch Movie", " ", $id).to_string() $(, $($skip),+)?),
+					overview: notsettable!(overview, concat!("Movie", " ", $id).to_string() $(, $($skip),+)?),
+					date: notsettable!(date, NaiveDate::from_yo_opt(2000, $id).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_movie!(&db, 1, Success);
+		assert_movie!(&db, 1, UniqueViolation);
+		assert_movie!(&db, 2, Success);
+		assert_movie!(&db, 3, Success; id);
+		assert_movie!(&db, 4, NotNullViolation; title);
+		assert_movie!(&db, 5, NotNullViolation; tagline);
+		assert_movie!(&db, 6, NotNullViolation; overview);
+		assert_movie!(&db, 7, NotNullViolation; date);
+
+		// Shows
+		macro_rules! assert_show {
+			($db:expr, $id:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_show!(@insert, $db, $id $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.id, ShowId::from_raw($id));
+				assert_eq!(model.title, concat!("S", $id));
+				assert_eq!(model.tagline, concat!("Watch Show", " ", $id));
+				assert_eq!(model.overview, concat!("Show", " ", $id));
+				assert_eq!(model.date, NaiveDate::from_yo_opt(2000, $id).expect("NaiveDate::from_yo_opt"));
+			};
+			($db:expr, $id:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_show!(@insert, $db, $id $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(
+					get_error_kind(model).expect("get_error_kind"),
+					ErrorKind::$error
+				);
+			};
+			(@insert, $db:expr, $id:literal $(; $($skip:ident),+)?) => {
+				super::shows::ActiveModel {
+					id: notsettable!(id, ShowId::from_raw($id) $(, $($skip),+)?),
+					title: notsettable!(title, concat!("S", $id).to_string() $(, $($skip),+)?),
+					tagline: notsettable!(tagline, concat!("Watch Show", " ", $id).to_string() $(, $($skip),+)?),
+					overview: notsettable!(overview, concat!("Show", " ", $id).to_string() $(, $($skip),+)?),
+					date: notsettable!(date, NaiveDate::from_yo_opt(2000, $id).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_show!(&db, 1, Success);
+		assert_show!(&db, 1, UniqueViolation);
+		assert_show!(&db, 2, Success);
+		assert_show!(&db, 3, Success; id);
+		assert_show!(&db, 4, NotNullViolation; title);
+		assert_show!(&db, 5, NotNullViolation; tagline);
+		assert_show!(&db, 6, NotNullViolation; overview);
+		assert_show!(&db, 7, NotNullViolation; date);
+
+		// Seasons
+		macro_rules! assert_season {
+			($db:expr, $show:literal, $season:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_season!(@insert, $db, $show, $season $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.show, ShowId::from_raw($show));
+				assert_eq!(model.season, $season);
+				assert_eq!(model.title, concat!("S", $show, "S", $season));
+				assert_eq!(model.overview, concat!("Show", " ", $show, " ", "Season", " ", $season));
+				assert_eq!(model.date, NaiveDate::from_yo_opt(2000, $show + $season).expect("NaiveDate::from_yo_opt"));
+			};
+			($db:expr, $show:literal, $season:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_season!(@insert, $db, $show, $season $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(
+					get_error_kind(model).expect("get_error_kind"),
+					ErrorKind::$error
+				);
+			};
+			(@insert, $db:expr, $show:literal, $season:literal $(; $($skip:ident),+)?) => {
+				super::seasons::ActiveModel {
+					show: notsettable!(show, ShowId::from_raw($show) $(, $($skip),+)?),
+					season: notsettable!(season, $season $(, $($skip),+)?),
+					title: notsettable!(title, concat!("S", $show, "S", $season).to_string() $(, $($skip),+)?),
+					overview: notsettable!(overview, concat!("Show", " ", $show, " ", "Season", " ", $season).to_string() $(, $($skip),+)?),
+					date: notsettable!(date, NaiveDate::from_yo_opt(2000, $show + $season).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_season!(&db, 1, 1, Success);
+		assert_season!(&db, 1, 1, UniqueViolation);
+		assert_season!(&db, 2, 1, Success);
+		assert_season!(&db, 0, 1, ForeignKeyViolation);
+		assert_season!(&db, 1, 2, Success);
+		assert_season!(&db, 1, 3, NotNullViolation; show);
+		assert_season!(&db, 1, 4, NotNullViolation; season);
+		assert_season!(&db, 1, 5, NotNullViolation; title);
+		assert_season!(&db, 1, 6, NotNullViolation; overview);
+		assert_season!(&db, 1, 7, NotNullViolation; date);
+
+		// Episodes
+		macro_rules! assert_episode {
+			($db:expr, $show:literal, $season:literal, $episode:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_episode!(@insert, $db, $show, $season, $episode $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.show, ShowId::from_raw($show));
+				assert_eq!(model.season, $season);
+				assert_eq!(model.episode, $episode);
+				assert_eq!(model.title, concat!("S", $show, "S", $season, "E", $episode));
+				assert_eq!(model.overview, concat!("Show", " ", $show, " ", "Season", " ", $season, " ", "Episode", " ", $episode));
+				assert_eq!(model.date, NaiveDate::from_yo_opt(2000, $show + $season + $episode).expect("NaiveDate::from_yo_opt"));
+			};
+			($db:expr, $show:literal, $season:literal, $episode:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_episode!(@insert, $db, $show, $season, $episode $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(
+					get_error_kind(model).expect("get_error_kind"),
+					ErrorKind::$error
+				);
+			};
+			(@insert, $db:expr, $show:literal, $season:literal, $episode:literal $(; $($skip:ident),+)?) => {
+				super::episodes::ActiveModel {
+					show: notsettable!(show, ShowId::from_raw($show) $(, $($skip),+)?),
+					season: notsettable!(season, $season $(, $($skip),+)?),
+					episode: notsettable!(episode, $episode $(, $($skip),+)?),
+					title: notsettable!(title, concat!("S", $show, "S", $season, "E", $episode).to_string() $(, $($skip),+)?),
+					overview: notsettable!(overview, concat!("Show", " ", $show, " ", "Season", " ", $season, " ", "Episode", " ", $episode).to_string() $(, $($skip),+)?),
+					date: notsettable!(date, NaiveDate::from_yo_opt(2000, $show + $season + $episode).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_episode!(&db, 1, 1, 1, Success);
+		assert_episode!(&db, 1, 1, 1, UniqueViolation);
+		assert_episode!(&db, 1, 2, 1, Success);
+		assert_episode!(&db, 2, 1, 1, Success);
+		assert_episode!(&db, 1, 0, 1, ForeignKeyViolation);
+		assert_episode!(&db, 0, 1, 1, ForeignKeyViolation);
+		assert_episode!(&db, 1, 1, 2, Success);
+		assert_episode!(&db, 1, 1, 3, NotNullViolation; show);
+		assert_episode!(&db, 1, 1, 4, NotNullViolation; season);
+		assert_episode!(&db, 1, 1, 4, NotNullViolation; episode);
+		assert_episode!(&db, 1, 1, 5, NotNullViolation; title);
+		assert_episode!(&db, 1, 1, 6, NotNullViolation; overview);
+		assert_episode!(&db, 1, 1, 7, NotNullViolation; date);
+	}
+}

crates/db/src/entity/info/movies.rs

@@ -0,0 +1,32 @@
+//! Movie entity
+
+use flix_model::id::MovieId;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a flix movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_info_movies")]
+pub struct Model {
+	/// The movie's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: MovieId,
+	/// The movie's title
+	pub title: String,
+	/// The movie's tagline
+	pub tagline: String,
+	/// The movie's overview
+	pub overview: String,
+	/// The movie's release date
+	pub date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/info/seasons.rs

@@ -0,0 +1,50 @@
+//! Season entity
+
+use flix_model::id::ShowId;
+
+use chrono::NaiveDate;
+use flix_model::numbers::SeasonNumber;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a flix season
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_info_seasons")]
+pub struct Model {
+	/// The season's show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub show: ShowId,
+	/// The season's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub season: SeasonNumber,
+	/// The season's title
+	pub title: String,
+	/// The season's overview
+	pub overview: String,
+	/// The season's air date
+	pub date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The show this season belongs to
+	#[sea_orm(
+		belongs_to = "super::shows::Entity",
+		from = "Column::Show",
+		to = "super::shows::Column::Id",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Show,
+}
+
+impl Related<super::shows::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Show.def()
+	}
+}

crates/db/src/entity/info/shows.rs

@@ -0,0 +1,51 @@
+//! Show entity
+
+use flix_model::id::ShowId;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a flix show
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_info_shows")]
+pub struct Model {
+	/// The show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: ShowId,
+	/// The show's title
+	pub title: String,
+	/// The show's tagline
+	pub tagline: String,
+	/// The show's overview
+	pub overview: String,
+	/// The show's air date
+	pub date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The seasons that are part of this show
+	#[sea_orm(has_many = "super::seasons::Entity")]
+	Seasons,
+	/// The episodes that are part of this show
+	#[sea_orm(has_many = "super::episodes::Entity")]
+	Episodes,
+}
+
+impl Related<super::seasons::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Seasons.def()
+	}
+}
+
+impl Related<super::episodes::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Episodes.def()
+	}
+}

crates/db/src/entity/mod.rs

@@ -0,0 +1,265 @@
+//! Entity structs for interacting with the database
+
+pub mod content;
+pub mod info;
+#[cfg(feature = "tmdb")]
+pub mod tmdb;
+pub mod watched;
+
+#[cfg(test)]
+mod tests {
+	pub use sea_orm::DbErr;
+	use sea_orm::sqlx::error::ErrorKind;
+
+	#[derive(Debug)]
+	pub enum ErrorKindError {
+		NotRuntimeError,
+		NotSqlxError,
+		NotDatabaseError,
+	}
+
+	pub fn get_error_kind(error: DbErr) -> Result<ErrorKind, ErrorKindError> {
+		let runtime_err = match error {
+			DbErr::Conn(runtime_err) => runtime_err,
+			DbErr::Exec(runtime_err) => runtime_err,
+			DbErr::Query(runtime_err) => runtime_err,
+			_ => return Err(ErrorKindError::NotRuntimeError),
+		};
+
+		let sqlx_err = match runtime_err {
+			sea_orm::RuntimeErr::SqlxError(sqlx_err) => sqlx_err,
+			_ => return Err(ErrorKindError::NotSqlxError),
+		};
+
+		let database_err = match sqlx_err.as_ref() {
+			sea_orm::SqlxError::Database(database_err) => database_err,
+			_ => return Err(ErrorKindError::NotDatabaseError),
+		};
+
+		Ok(database_err.kind())
+	}
+
+	/// Helper macro for writing tests for `ActiveModel` structs where
+	/// toggling [sea_orm::ActiveValue] is needed
+	macro_rules! notsettable {
+		($field:ident, $value:expr $(, $($skip:ident),+)?) => {
+			if notsettable!(@skip, $field $(, $($skip),+)?) {
+				NotSet
+			} else {
+				Set($value)
+			}
+		};
+		(@skip, $field:ident $(, $skip:ident),*) => {
+			false $(|| stringify!($field) == stringify!($skip))*
+		};
+	}
+	pub(super) use notsettable;
+
+	/// Helper macro for writing tests for `ActiveModel` structs where
+	/// toggling [sea_orm::ActiveValue] is needed
+	macro_rules! noneable {
+		($field:ident, $value:expr $(, $($skip:ident),+)?) => {
+			if noneable!(@skip, $field $(, $($skip),+)?) {
+				None
+			} else {
+				Some($value)
+			}
+		};
+		(@skip, $field:ident $(, $skip:ident),*) => {
+			false $(|| stringify!($field) == stringify!($skip))*
+		};
+	}
+	pub(super) use noneable;
+
+	/// Helper macro for creating a flix library
+	macro_rules! have_library {
+		($db:expr, $id:literal) => {
+			$crate::entity::content::libraries::ActiveModel {
+				id: Set(::flix_model::id::LibraryId::from_raw($id)),
+				directory: Set(::std::path::PathBuf::new().into()),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use have_library;
+
+	/// Helper macro for creating a flix collection
+	macro_rules! make_flix_collection {
+		($db:expr, $id:literal) => {
+			$crate::entity::info::collections::ActiveModel {
+				id: Set(::flix_model::id::CollectionId::from_raw($id)),
+				title: Set(::std::string::String::new()),
+				overview: Set(::std::string::String::new()),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use make_flix_collection;
+	macro_rules! have_collection {
+		($db:expr, $lid:literal, $id:literal, $pid:expr) => {
+			$crate::entity::tests::make_flix_collection!($db, $id);
+			$crate::entity::content::collections::ActiveModel {
+				id: Set(::flix_model::id::CollectionId::from_raw($id)),
+				parent: Set($pid.map(::flix_model::id::CollectionId::from_raw)),
+				slug: Set(::std::string::String::new()),
+				library: Set(::flix_model::id::LibraryId::from_raw($lid)),
+				directory: Set(::std::path::PathBuf::new().into()),
+				relative_poster_path: Set(None),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use have_collection;
+
+	/// Helper macro for creating a flix movie
+	macro_rules! make_flix_movie {
+		($db:expr, $id:literal) => {
+			$crate::entity::info::movies::ActiveModel {
+				id: Set(::flix_model::id::MovieId::from_raw($id)),
+				title: Set(::std::string::String::new()),
+				tagline: Set(::std::string::String::new()),
+				overview: Set(::std::string::String::new()),
+				date: Set(
+					::chrono::NaiveDate::from_yo_opt(2000, $id).expect("NaiveDate::from_yo_opt")
+				),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use make_flix_movie;
+	macro_rules! have_movie {
+		($db:expr, $lid:literal, $id:literal, $pid:expr) => {
+			$crate::entity::tests::make_flix_movie!($db, $id);
+			$crate::entity::content::movies::ActiveModel {
+				id: Set(::flix_model::id::MovieId::from_raw($id)),
+				parent: Set($pid.map(::flix_model::id::CollectionId::from_raw)),
+				slug: Set(::std::string::String::new()),
+				library: Set(::flix_model::id::LibraryId::from_raw($lid)),
+				directory: Set(::std::path::PathBuf::new().into()),
+				relative_media_path: Set(::std::path::PathBuf::new().into()),
+				relative_poster_path: Set(None),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use have_movie;
+
+	/// Helper macro for creating a flix show
+	macro_rules! make_flix_show {
+		($db:expr, $id:literal) => {
+			$crate::entity::info::shows::ActiveModel {
+				id: Set(::flix_model::id::ShowId::from_raw($id)),
+				title: Set(::std::string::String::new()),
+				tagline: Set(::std::string::String::new()),
+				overview: Set(::std::string::String::new()),
+				date: Set(
+					::chrono::NaiveDate::from_yo_opt(2000, $id).expect("NaiveDate::from_yo_opt")
+				),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use make_flix_show;
+	macro_rules! have_show {
+		($db:expr, $lid:literal, $id:literal, $pid:expr) => {
+			$crate::entity::tests::make_flix_show!($db, $id);
+			$crate::entity::content::shows::ActiveModel {
+				id: Set(::flix_model::id::ShowId::from_raw($id)),
+				parent: Set($pid.map(::flix_model::id::CollectionId::from_raw)),
+				slug: Set(::std::string::String::new()),
+				library: Set(::flix_model::id::LibraryId::from_raw($lid)),
+				directory: Set(::std::path::PathBuf::new().into()),
+				relative_poster_path: Set(None),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use have_show;
+
+	/// Helper macro for creating a flix season
+	macro_rules! make_flix_season {
+		($db:expr, $show:literal, $season:literal) => {
+			$crate::entity::info::seasons::ActiveModel {
+				show: Set(::flix_model::id::ShowId::from_raw($show)),
+				season: Set($season),
+				title: Set(::std::string::String::new()),
+				overview: Set(::std::string::String::new()),
+				date: Set(::chrono::NaiveDate::from_yo_opt(2000, $show + $season)
+					.expect("NaiveDate::from_yo_opt")),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use make_flix_season;
+	macro_rules! have_season {
+		($db:expr, $lid:literal, $show:literal, $season:literal) => {
+			$crate::entity::tests::make_flix_season!($db, $show, $season);
+			$crate::entity::content::seasons::ActiveModel {
+				show: Set(::flix_model::id::ShowId::from_raw($show)),
+				season: Set($season),
+				slug: Set(::std::string::String::new()),
+				library: Set(::flix_model::id::LibraryId::from_raw($lid)),
+				directory: Set(::std::path::PathBuf::new().into()),
+				relative_poster_path: Set(None),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use have_season;
+
+	/// Helper macro for creating a flix episode
+	macro_rules! make_flix_episode {
+		($db:expr, $show:literal, $season:literal, $episode:literal) => {
+			$crate::entity::info::episodes::ActiveModel {
+				show: Set(::flix_model::id::ShowId::from_raw($show)),
+				season: Set($season),
+				episode: Set($episode),
+				title: Set(::std::string::String::new()),
+				overview: Set(::std::string::String::new()),
+				date: Set(::chrono::NaiveDate::from_yo_opt(2000, $show + $season)
+					.expect("NaiveDate::from_yo_opt")),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use make_flix_episode;
+	macro_rules! have_episode {
+		($db:expr, $lid:literal, $show:literal, $season:literal, $episode:literal) => {
+			$crate::entity::tests::make_flix_episode!($db, $show, $season, $episode);
+			$crate::entity::content::episodes::ActiveModel {
+				show: Set(::flix_model::id::ShowId::from_raw($show)),
+				season: Set($season),
+				episode: Set($episode),
+				slug: Set(::std::string::String::new()),
+				library: Set(::flix_model::id::LibraryId::from_raw($lid)),
+				directory: Set(::std::path::PathBuf::new().into()),
+				relative_media_path: Set(::std::path::PathBuf::new().into()),
+				relative_poster_path: Set(None),
+			}
+			.insert($db)
+			.await
+			.expect("insert");
+		};
+	}
+	pub(super) use have_episode;
+}

crates/db/src/entity/tmdb/collections.rs

@@ -0,0 +1,41 @@
+//! Collection entity
+
+use flix_model::id::CollectionId as FlixId;
+use flix_tmdb::model::id::CollectionId;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a tmdb collection
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_tmdb_collections")]
+pub struct Model {
+	/// The collection's TMDB ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_id: CollectionId,
+	/// The collection's ID
+	pub flix_id: FlixId,
+	/// The date of the last update
+	pub last_update: NaiveDate,
+	/// The number of movies in the collection
+	pub movie_count: u16,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The movies that are part of this collection
+	#[sea_orm(has_many = "super::movies::Entity")]
+	Movies,
+}
+
+impl Related<super::movies::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Movies.def()
+	}
+}

crates/db/src/entity/tmdb/episodes.rs

@@ -0,0 +1,43 @@
+//! Season entity
+
+use flix_model::id::ShowId as FlixId;
+use flix_model::numbers::{EpisodeNumber, SeasonNumber};
+use flix_tmdb::model::id::ShowId;
+use seamantic::model::duration::Seconds;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a tmdb episode
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_tmdb_episodes")]
+pub struct Model {
+	/// The episode's show's TMDB ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_show: ShowId,
+	/// The episode's season's TMDB season number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_season: SeasonNumber,
+	/// The episode's TMDB episode number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_episode: EpisodeNumber,
+	/// The episode's show's ID
+	pub flix_show: FlixId,
+	/// The episode's season's number
+	pub flix_season: SeasonNumber,
+	/// The episode's number
+	pub flix_episode: EpisodeNumber,
+	/// The date of the last update
+	pub last_update: NaiveDate,
+	/// The episode's runtime in seconds
+	pub runtime: Seconds,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/tmdb/mod.rs

@@ -0,0 +1,278 @@
+//! This module contains entities for storing dynamic data from TMDB
+
+pub mod collections;
+
+pub mod movies;
+
+pub mod episodes;
+pub mod seasons;
+pub mod shows;
+
+#[cfg(test)]
+mod tests {
+	use core::time::Duration;
+
+	use flix_model::id::{CollectionId, MovieId, ShowId};
+	use flix_tmdb::model::id::{
+		CollectionId as TmdbCollectionId, MovieId as TmdbMovieId, ShowId as TmdbShowId,
+	};
+
+	use chrono::NaiveDate;
+	use sea_orm::ActiveModelTrait;
+	use sea_orm::ActiveValue::{NotSet, Set};
+	use sea_orm::sqlx::error::ErrorKind;
+	use sea_orm_migration::MigratorTrait;
+
+	use crate::migration::Migrator;
+	use crate::tests::new_memory_db;
+
+	use super::super::tests::get_error_kind;
+	use super::super::tests::notsettable;
+	use super::super::tests::{
+		make_flix_collection, make_flix_episode, make_flix_movie, make_flix_season, make_flix_show,
+	};
+
+	#[tokio::test]
+	async fn test_inserts() {
+		let db = new_memory_db().await;
+		Migrator::up(&db, None).await.expect("up");
+
+		// Collections
+		macro_rules! assert_collection {
+			($db:expr, $id:literal, $tid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_collection!(@insert, $db, $id, $tid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.tmdb_id, TmdbCollectionId::from_raw($tid));
+				assert_eq!(model.flix_id, CollectionId::from_raw($id));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tid).expect("NaiveDate::from_yo_opt"));
+				assert_eq!(model.movie_count, $id);
+			};
+			($db:expr, $id:literal, $tid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_collection!(@insert, $db, $id, $tid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $tid:literal $(; $($skip:ident),+)?) => {
+				super::collections::ActiveModel {
+					tmdb_id: notsettable!(tmdb_id, TmdbCollectionId::from_raw($tid) $(, $($skip),+)?),
+					flix_id: notsettable!(flix_id, CollectionId::from_raw($id) $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tid).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+					movie_count: notsettable!(movie_count, $id $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_collection!(&db, 1, 1, ForeignKeyViolation);
+		make_flix_collection!(&db, 1);
+		make_flix_collection!(&db, 2);
+		make_flix_collection!(&db, 3);
+
+		assert_collection!(&db, 1, 1, Success);
+		assert_collection!(&db, 1, 1, UniqueViolation);
+		assert_collection!(&db, 1, 2, UniqueViolation);
+		assert_collection!(&db, 2, 1, UniqueViolation);
+		assert_collection!(&db, 2, 2, Success);
+		assert_collection!(&db, 3, 3, Success; tmdb_id);
+		assert_collection!(&db, 4, 4, NotNullViolation; flix_id);
+		assert_collection!(&db, 5, 5, NotNullViolation; last_update);
+		assert_collection!(&db, 6, 6, NotNullViolation; movie_count);
+
+		// Movies
+		macro_rules! assert_movie {
+			($db:expr, $id:literal, $tid:literal, $cid:expr, Success $(; $($skip:ident),+)?) => {
+				let model = assert_movie!(@insert, $db, $id, $tid, $cid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.tmdb_id, TmdbMovieId::from_raw($tid));
+				assert_eq!(model.flix_id, MovieId::from_raw($id));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tid).expect("NaiveDate::from_yo_opt"));
+				assert_eq!(model.runtime, Duration::from_secs($tid).into());
+				assert_eq!(model.collection, $cid);
+			};
+			($db:expr, $id:literal, $tid:literal, $cid:expr, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_movie!(@insert, $db, $id, $tid, $cid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+			};
+			(@insert, $db:expr, $id:literal, $tid:literal, $cid:expr $(; $($skip:ident),+)?) => {
+				super::movies::ActiveModel {
+					tmdb_id: notsettable!(tmdb_id, TmdbMovieId::from_raw($tid) $(, $($skip),+)?),
+					flix_id: notsettable!(flix_id, MovieId::from_raw($id) $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tid).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+					runtime: notsettable!(runtime, Duration::from_secs($tid).into() $(, $($skip),+)?),
+					collection: notsettable!(collection, $cid $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_movie!(
+			&db,
+			1,
+			1,
+			Some(TmdbCollectionId::from_raw(1)),
+			ForeignKeyViolation
+		);
+		make_flix_movie!(&db, 1);
+		make_flix_movie!(&db, 2);
+		make_flix_movie!(&db, 3);
+
+		assert_movie!(&db, 1, 1, Some(TmdbCollectionId::from_raw(1)), Success);
+		assert_movie!(&db, 1, 1, None, UniqueViolation);
+		assert_movie!(&db, 1, 2, None, UniqueViolation);
+		assert_movie!(&db, 2, 1, None, UniqueViolation);
+		assert_movie!(&db, 2, 2, Some(TmdbCollectionId::from_raw(1)), Success);
+		assert_movie!(&db, 3, 3, None, Success; tmdb_id);
+		assert_movie!(&db, 4, 4, None, NotNullViolation; flix_id);
+		assert_movie!(&db, 5, 5, None, NotNullViolation; last_update);
+		assert_movie!(&db, 6, 6, None, NotNullViolation; runtime);
+		assert_movie!(&db, 7, 7, None, ForeignKeyViolation; collection); // Must be `Set(None)`
+
+		// Shows
+		macro_rules! assert_show {
+			($db:expr, $id:literal, $tid:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_show!(@insert, $db, $id, $tid $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.tmdb_id, TmdbShowId::from_raw($tid));
+				assert_eq!(model.flix_id, ShowId::from_raw($id));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tid).expect("NaiveDate::from_yo_opt"));
+				assert_eq!(model.number_of_seasons, $id);
+			};
+			($db:expr, $id:literal, $tid:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_show!(@insert, $db, $id, $tid $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(
+					get_error_kind(model).expect("get_error_kind"),
+					ErrorKind::$error
+				);
+			};
+			(@insert, $db:expr, $id:literal, $tid:literal $(; $($skip:ident),+)?) => {
+				super::shows::ActiveModel {
+					tmdb_id: notsettable!(tmdb_id, TmdbShowId::from_raw($tid) $(, $($skip),+)?),
+					flix_id: notsettable!(flix_id, ShowId::from_raw($id) $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tid).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+					number_of_seasons: notsettable!(number_of_seasons, $id $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_show!(&db, 1, 1, ForeignKeyViolation);
+		make_flix_show!(&db, 1);
+		make_flix_show!(&db, 2);
+		make_flix_show!(&db, 3);
+
+		assert_show!(&db, 1, 1, Success);
+		assert_show!(&db, 1, 1, UniqueViolation);
+		assert_show!(&db, 1, 2, UniqueViolation);
+		assert_show!(&db, 2, 1, UniqueViolation);
+		assert_show!(&db, 2, 2, Success);
+		assert_show!(&db, 3, 3, Success; tmdb_id);
+		assert_show!(&db, 4, 4, NotNullViolation; flix_id);
+		assert_show!(&db, 5, 5, NotNullViolation; last_update);
+		assert_show!(&db, 6, 6, NotNullViolation; number_of_seasons);
+
+		// Seasons
+		macro_rules! assert_season {
+			($db:expr, $show:literal, $season:literal, $tshow:literal, $tseason:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_season!(@insert, $db, $show, $season, $tshow, $tseason $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.tmdb_show, TmdbShowId::from_raw($tshow));
+				assert_eq!(model.tmdb_season, $tseason);
+				assert_eq!(model.flix_show, ShowId::from_raw($show));
+				assert_eq!(model.flix_season, $season);
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt"));
+			};
+			($db:expr, $show:literal, $season:literal, $tshow:literal, $tseason:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_season!(@insert, $db, $show, $season, $tshow, $tseason $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(
+					get_error_kind(model).expect("get_error_kind"),
+					ErrorKind::$error
+				);
+			};
+			(@insert, $db:expr, $show:literal, $season:literal, $tshow:literal, $tseason:literal $(; $($skip:ident),+)?) => {
+				super::seasons::ActiveModel {
+					tmdb_show: notsettable!(tmdb_show, TmdbShowId::from_raw($tshow) $(, $($skip),+)?),
+					tmdb_season: notsettable!(tmdb_season, $tseason $(, $($skip),+)?),
+					flix_show: notsettable!(flix_show, ShowId::from_raw($show) $(, $($skip),+)?),
+					flix_season: notsettable!(flix_season, $season $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_season!(&db, 1, 1, 1, 1, ForeignKeyViolation);
+		make_flix_season!(&db, 1, 1);
+		make_flix_season!(&db, 1, 2);
+
+		assert_season!(&db, 1, 1, 1, 1, Success);
+		assert_season!(&db, 1, 1, 1, 1, UniqueViolation);
+		assert_season!(&db, 1, 1, 2, 1, UniqueViolation);
+		assert_season!(&db, 2, 1, 1, 1, UniqueViolation);
+		assert_season!(&db, 1, 2, 1, 2, Success);
+		assert_season!(&db, 1, 3, 1, 3, NotNullViolation; tmdb_show);
+		assert_season!(&db, 1, 4, 1, 4, NotNullViolation; tmdb_season);
+		assert_season!(&db, 1, 5, 1, 5, NotNullViolation; flix_show);
+		assert_season!(&db, 1, 6, 1, 6, NotNullViolation; flix_season);
+		assert_season!(&db, 1, 7, 1, 7, NotNullViolation; last_update);
+
+		// Episodes
+		macro_rules! assert_episode {
+			($db:expr, $show:literal, $season:literal, $episode:literal, $tshow:literal, $tseason:literal, $tepisode:literal, Success $(; $($skip:ident),+)?) => {
+				let model = assert_episode!(@insert, $db, $show, $season, $episode, $tshow, $tseason, $tepisode $(; $($skip),+)?)
+					.expect("insert");
+
+				assert_eq!(model.tmdb_show, TmdbShowId::from_raw($tshow));
+				assert_eq!(model.tmdb_season, $tseason);
+				assert_eq!(model.tmdb_episode, $tepisode);
+				assert_eq!(model.flix_show, ShowId::from_raw($show));
+				assert_eq!(model.flix_season, $season);
+				assert_eq!(model.flix_episode, $episode);
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt"));
+				assert_eq!(model.runtime, Duration::from_secs($tshow).into());
+			};
+			($db:expr, $show:literal, $season:literal, $episode:literal, $tshow:literal, $tseason:literal, $tepisode:literal, $error:ident $(; $($skip:ident),+)?) => {
+				let model = assert_episode!(@insert, $db, $show, $season, $episode, $tshow, $tseason, $tepisode $(; $($skip),+)?)
+					.expect_err("insert");
+
+				assert_eq!(
+					get_error_kind(model).expect("get_error_kind"),
+					ErrorKind::$error
+				);
+			};
+			(@insert, $db:expr, $show:literal, $season:literal, $episode:literal, $tshow:literal, $tseason:literal, $tepisode:literal $(; $($skip:ident),+)?) => {
+				super::episodes::ActiveModel {
+					tmdb_show: notsettable!(tmdb_show, TmdbShowId::from_raw($tshow) $(, $($skip),+)?),
+					tmdb_season: notsettable!(tmdb_season, $tseason $(, $($skip),+)?),
+					tmdb_episode: notsettable!(tmdb_episode, $tepisode $(, $($skip),+)?),
+					flix_show: notsettable!(flix_show, ShowId::from_raw($show) $(, $($skip),+)?),
+					flix_season: notsettable!(flix_season, $season $(, $($skip),+)?),
+					flix_episode: notsettable!(flix_episode, $episode $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+					runtime: notsettable!(runtime, Duration::from_secs($tshow).into() $(, $($skip),+)?),
+				}.insert($db).await
+			};
+		}
+		assert_episode!(&db, 1, 1, 1, 1, 1, 1, ForeignKeyViolation);
+		make_flix_episode!(&db, 1, 1, 1);
+		make_flix_episode!(&db, 1, 1, 2);
+
+		assert_episode!(&db, 1, 1, 1, 1, 1, 1, Success);
+		assert_episode!(&db, 1, 1, 1, 1, 1, 1, UniqueViolation);
+		assert_episode!(&db, 1, 1, 1, 1, 2, 1, UniqueViolation);
+		assert_episode!(&db, 1, 1, 1, 2, 1, 1, UniqueViolation);
+		assert_episode!(&db, 1, 2, 1, 1, 1, 1, UniqueViolation);
+		assert_episode!(&db, 2, 1, 1, 1, 1, 1, UniqueViolation);
+		assert_episode!(&db, 1, 1, 2, 1, 1, 2, Success);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 3, NotNullViolation; tmdb_show);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 4, NotNullViolation; tmdb_season);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 5, NotNullViolation; tmdb_episode);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 6, NotNullViolation; flix_show);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 7, NotNullViolation; flix_season);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 8, NotNullViolation; flix_episode);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 9, NotNullViolation; last_update);
+		assert_episode!(&db, 1, 1, 3, 1, 1, 10, NotNullViolation; runtime);
+	}
+}

crates/db/src/entity/tmdb/movies.rs

@@ -0,0 +1,51 @@
+//! Movie entity
+
+use flix_model::id::MovieId as FlixId;
+use flix_tmdb::model::id::{CollectionId, MovieId};
+
+use seamantic::model::duration::Seconds;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a tmdb movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_tmdb_movies")]
+pub struct Model {
+	/// The movie's TMDB ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_id: MovieId,
+	/// The movie's ID
+	pub flix_id: FlixId,
+	/// The date of the last update
+	pub last_update: NaiveDate,
+	/// The movie's runtime in seconds
+	pub runtime: Seconds,
+	/// The TMDB ID of the collection this movie belongs to
+	pub collection: Option<CollectionId>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The collection this movie belongs to
+	#[sea_orm(
+		belongs_to = "super::collections::Entity",
+		from = "Column::Collection",
+		to = "super::collections::Column::TmdbId",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Collection,
+}
+
+impl Related<super::collections::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Collection.def()
+	}
+}

crates/db/src/entity/tmdb/seasons.rs

@@ -0,0 +1,51 @@
+//! Season entity
+
+use flix_model::id::ShowId as FlixId;
+use flix_model::numbers::SeasonNumber;
+use flix_tmdb::model::id::ShowId;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a tmdb season
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_tmdb_seasons")]
+pub struct Model {
+	/// The season's show's TMDB ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_show: ShowId,
+	/// The season's TMDB season number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_season: SeasonNumber,
+	/// The season's show's ID
+	pub flix_show: FlixId,
+	/// The season's number
+	pub flix_season: SeasonNumber,
+	/// The date of the last update
+	pub last_update: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The show this season belongs to
+	#[sea_orm(
+		belongs_to = "super::shows::Entity",
+		from = "Column::TmdbShow",
+		to = "super::shows::Column::TmdbId",
+		on_update = "Cascade",
+		on_delete = "Cascade"
+	)]
+	Show,
+}
+
+impl Related<super::shows::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Show.def()
+	}
+}

crates/db/src/entity/tmdb/shows.rs

@@ -0,0 +1,41 @@
+//! Show entity
+
+use flix_model::id::ShowId as FlixId;
+use flix_tmdb::model::id::ShowId;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EntityTrait,
+	EnumIter, PrimaryKeyTrait, Related, RelationDef, RelationTrait,
+};
+
+/// The database representation of a tmdb show
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_tmdb_shows")]
+pub struct Model {
+	/// The show's TMDB ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub tmdb_id: ShowId,
+	/// The show's ID
+	pub flix_id: FlixId,
+	/// The movie's runtime in seconds
+	pub last_update: NaiveDate,
+	/// The number of seasons the show has
+	pub number_of_seasons: u32,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+	/// The seasons that are part of this show
+	#[sea_orm(has_many = "super::seasons::Entity")]
+	Seasons,
+}
+
+impl Related<super::seasons::Entity> for Entity {
+	fn to() -> RelationDef {
+		Relation::Seasons.def()
+	}
+}

crates/db/src/entity/watched/collections.rs

@@ -0,0 +1,26 @@
+//! Collection entity
+
+use flix_model::id::{CollectionId, RawId};
+
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a watched movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_watched_collections")]
+pub struct Model {
+	/// The collection's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: CollectionId,
+	/// The user's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub user_id: RawId,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/watched/episodes.rs

@@ -0,0 +1,36 @@
+//! Episode entity
+
+use flix_model::id::{RawId, ShowId};
+use flix_model::numbers::{EpisodeNumber, SeasonNumber};
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a watched movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_watched_episodes")]
+pub struct Model {
+	/// The episode's show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub show: ShowId,
+	/// The episode's season's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub season: SeasonNumber,
+	/// The episode's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub episode: EpisodeNumber,
+	/// The user's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub user_id: RawId,
+	/// The date this episode was watched
+	pub watched_date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/watched/mod.rs

@@ -0,0 +1,291 @@
+//! This module contains entities for storing watched information
+
+pub mod collections;
+
+pub mod movies;
+
+pub mod episodes;
+pub mod seasons;
+pub mod shows;
+
+#[cfg(test)]
+mod tests {
+
+	use flix_model::id::{MovieId, ShowId};
+
+	use chrono::NaiveDate;
+	use sea_orm::ActiveValue::{NotSet, Set};
+	use sea_orm::sqlx::error::ErrorKind;
+	use sea_orm::{ActiveModelTrait, ColumnTrait, Condition, EntityTrait, QueryFilter};
+	use sea_orm_migration::MigratorTrait;
+
+	use crate::entity::tests::{have_collection, have_library, have_movie, have_season, have_show};
+	use crate::migration::Migrator;
+	use crate::tests::new_memory_db;
+
+	use super::super::tests::get_error_kind;
+	use super::super::tests::notsettable;
+	use super::super::tests::{
+		have_episode, make_flix_episode, make_flix_movie, make_flix_season, make_flix_show,
+	};
+
+	macro_rules! assert_movie {
+		($db:expr, $id:literal, $uid:literal, Success $(; $($skip:ident),+)?) => {
+			let model = assert_movie!(@insert, $db, $id, $uid $(; $($skip),+)?)
+				.expect("insert");
+
+			assert_eq!(model.id, MovieId::from_raw($id));
+			assert_eq!(model.user_id, $uid);
+			assert_eq!(model.watched_date, NaiveDate::from_yo_opt(2000, $uid).expect("NaiveDate::from_yo_opt"));
+		};
+		($db:expr, $id:literal, $uid:literal, $error:ident $(; $($skip:ident),+)?) => {
+			let model = assert_movie!(@insert, $db, $id, $uid $(; $($skip),+)?)
+				.expect_err("insert");
+
+			assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+		};
+		(@insert, $db:expr, $id:literal, $uid:literal $(; $($skip:ident),+)?) => {
+			super::movies::ActiveModel {
+				id: notsettable!(id, MovieId::from_raw($id) $(, $($skip),+)?),
+				user_id: notsettable!(user_id, $uid $(, $($skip),+)?),
+				watched_date: notsettable!(watched_date, NaiveDate::from_yo_opt(2000, $uid).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+			}.insert($db).await
+		};
+	}
+
+	macro_rules! assert_episode {
+		($db:expr, $show:literal, $season:literal, $episode:literal, $uid:literal, Success $(; $($skip:ident),+)?) => {
+			let model = assert_episode!(@insert, $db, $show, $season, $episode, $uid $(; $($skip),+)?)
+				.expect("insert");
+
+			assert_eq!(model.show, ShowId::from_raw($show));
+			assert_eq!(model.season, $season);
+			assert_eq!(model.episode, $episode);
+			assert_eq!(model.user_id, $uid);
+			assert_eq!(model.watched_date, NaiveDate::from_yo_opt(2000, $uid).expect("NaiveDate::from_yo_opt"));
+		};
+		($db:expr, $show:literal, $season:literal, $episode:literal, $uid:literal, $error:ident $(; $($skip:ident),+)?) => {
+			let model = assert_episode!(@insert, $db, $show, $season, $episode, $uid $(; $($skip),+)?)
+				.expect_err("insert");
+
+			assert_eq!(get_error_kind(model).expect("get_error_kind"), ErrorKind::$error);
+		};
+		(@insert, $db:expr, $show:literal, $season:literal, $episode:literal, $uid:literal $(; $($skip:ident),+)?) => {
+			super::episodes::ActiveModel {
+				show: notsettable!(show, ShowId::from_raw($show) $(, $($skip),+)?),
+				season: notsettable!(season, $season $(, $($skip),+)?),
+				episode: notsettable!(episode, $episode $(, $($skip),+)?),
+				user_id: notsettable!(user_id, $uid $(, $($skip),+)?),
+				watched_date: notsettable!(watched_date, NaiveDate::from_yo_opt(2000, $uid).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+			}.insert($db).await
+		};
+	}
+
+	#[tokio::test]
+	async fn test_inserts() {
+		let db = new_memory_db().await;
+		Migrator::up(&db, None).await.expect("up");
+
+		// Movies
+		assert_movie!(&db, 1, 1, ForeignKeyViolation);
+		make_flix_movie!(&db, 1);
+		make_flix_movie!(&db, 2);
+
+		assert_movie!(&db, 1, 1, Success);
+		assert_movie!(&db, 1, 1, UniqueViolation);
+		assert_movie!(&db, 2, 1, Success);
+		assert_movie!(&db, 3, 1, NotNullViolation; id);
+		assert_movie!(&db, 4, 1, NotNullViolation; user_id);
+		assert_movie!(&db, 5, 1, NotNullViolation; watched_date);
+
+		// Episodes
+		make_flix_show!(&db, 1);
+		make_flix_season!(&db, 1, 1);
+		make_flix_show!(&db, 2);
+		make_flix_season!(&db, 2, 1);
+
+		assert_episode!(&db, 1, 1, 1, 1, ForeignKeyViolation);
+		make_flix_episode!(&db, 1, 1, 1);
+		make_flix_episode!(&db, 1, 1, 2);
+		make_flix_episode!(&db, 2, 1, 1);
+
+		assert_episode!(&db, 1, 1, 1, 1, Success);
+		assert_episode!(&db, 1, 1, 1, 1, UniqueViolation);
+		assert_episode!(&db, 1, 1, 2, 1, Success);
+		assert_episode!(&db, 2, 1, 1, 1, Success);
+		assert_episode!(&db, 3, 1, 1, 1, NotNullViolation; show);
+		assert_episode!(&db, 4, 1, 1, 1, NotNullViolation; season);
+		assert_episode!(&db, 5, 1, 1, 1, NotNullViolation; episode);
+		assert_episode!(&db, 6, 1, 1, 1, NotNullViolation; user_id);
+		assert_episode!(&db, 7, 1, 1, 1, NotNullViolation; watched_date);
+	}
+
+	#[tokio::test]
+	async fn test_queries() {
+		let db = new_memory_db().await;
+		Migrator::up(&db, None).await.expect("up");
+
+		have_library!(&db, 1);
+
+		// Season + Show
+		macro_rules! assert_season {
+			($db:expr, $show:literal, $season:literal, $uid:literal, Watched) => {
+				assert_season!(@find, $db, $show, $season, $uid)
+					.ok_or(())
+					.expect("is none");
+			};
+			($db:expr, $show:literal, $season:literal, $uid:literal, Unwatched) => {
+				assert_season!(@find, $db, $show, $season, $uid)
+					.ok_or(())
+					.expect_err("is some");
+			};
+			(@find, $db:expr, $show:literal, $season:literal, $uid:literal) => {
+				super::seasons::Entity::find()
+					.filter(
+						Condition::all()
+							.add(super::seasons::Column::Show.eq($show))
+							.add(super::seasons::Column::Season.eq($season))
+							.add(super::seasons::Column::UserId.eq($uid)),
+					)
+					.one(&db)
+					.await
+					.expect("find.filter.one")
+			};
+		}
+		macro_rules! assert_show {
+			($db:expr, $show:literal, $uid:literal, Watched) => {
+				assert_show!(@find, $db, $show, $uid)
+					.ok_or(())
+					.expect("is none");
+			};
+			($db:expr, $show:literal, $uid:literal, Unwatched) => {
+				assert_show!(@find, $db, $show, $uid)
+					.ok_or(())
+					.expect_err("is some");
+			};
+			(@find, $db:expr, $show:literal, $uid:literal) => {
+				super::shows::Entity::find()
+					.filter(
+						Condition::all()
+							.add(super::shows::Column::Id.eq($show))
+							.add(super::shows::Column::UserId.eq($uid)),
+					)
+					.one(&db)
+					.await
+					.expect("find.filter.one")
+			};
+		}
+
+		have_show!(&db, 1, 1, None);
+		have_season!(&db, 1, 1, 1);
+		have_episode!(&db, 1, 1, 1, 1);
+		assert_episode!(&db, 1, 1, 1, 1, Success);
+		assert_episode!(&db, 1, 1, 1, 2, Success);
+		have_episode!(&db, 1, 1, 1, 2);
+		assert_episode!(&db, 1, 1, 2, 1, Success);
+		assert_episode!(&db, 1, 1, 2, 2, Success);
+		have_episode!(&db, 1, 1, 1, 3);
+		assert_episode!(&db, 1, 1, 3, 1, Success);
+		assert_episode!(&db, 1, 1, 3, 2, Success);
+		have_season!(&db, 1, 1, 2);
+		have_episode!(&db, 1, 1, 2, 1);
+		assert_episode!(&db, 1, 2, 1, 1, Success);
+		assert_episode!(&db, 1, 2, 1, 2, Success);
+		have_episode!(&db, 1, 1, 2, 2);
+		assert_episode!(&db, 1, 2, 2, 1, Success);
+		have_episode!(&db, 1, 1, 2, 3);
+		assert_episode!(&db, 1, 2, 3, 1, Success);
+
+		// Add watched episodes that we do not have
+		make_flix_episode!(&db, 1, 1, 4);
+		assert_episode!(&db, 1, 1, 4, 1, Success);
+		make_flix_episode!(&db, 1, 2, 4);
+		assert_episode!(&db, 1, 2, 4, 2, Success);
+		make_flix_episode!(&db, 1, 2, 5);
+		assert_episode!(&db, 1, 2, 5, 2, Success);
+
+		assert_season!(&db, 1, 1, 1, Watched);
+		assert_season!(&db, 1, 1, 2, Watched);
+		assert_season!(&db, 1, 1, 3, Unwatched);
+		assert_season!(&db, 1, 2, 1, Watched);
+		assert_season!(&db, 1, 2, 2, Unwatched);
+		assert_season!(&db, 1, 2, 3, Unwatched);
+		assert_season!(&db, 1, 3, 1, Unwatched);
+		assert_season!(&db, 1, 3, 2, Unwatched);
+		assert_season!(&db, 1, 3, 3, Unwatched);
+
+		assert_show!(&db, 1, 1, Watched);
+		assert_show!(&db, 1, 2, Unwatched);
+		assert_show!(&db, 1, 3, Unwatched);
+		assert_show!(&db, 2, 1, Unwatched);
+		assert_show!(&db, 2, 2, Unwatched);
+		assert_show!(&db, 2, 3, Unwatched);
+
+		// Collection
+		macro_rules! assert_collection {
+			($db:expr, $id:literal, $uid:literal, Watched) => {
+				assert_collection!(@find, $db, $id, $uid)
+					.ok_or(())
+					.expect("is none");
+			};
+			($db:expr, $id:literal, $uid:literal, Unwatched) => {
+				assert_collection!(@find, $db, $id, $uid)
+					.ok_or(())
+					.expect_err("is some");
+			};
+			(@find, $db:expr, $id:literal, $uid:literal) => {
+				super::collections::Entity::find()
+					.filter(
+						Condition::all()
+							.add(super::collections::Column::Id.eq($id))
+							.add(super::collections::Column::UserId.eq($uid)),
+					)
+					.one(&db)
+					.await
+					.expect("find.filter.one")
+			};
+		}
+
+		have_collection!(&db, 1, 1, None);
+		have_movie!(&db, 1, 1, Some(1));
+		assert_movie!(&db, 1, 1, Success);
+		assert_movie!(&db, 1, 2, Success);
+		have_movie!(&db, 1, 2, Some(1));
+		assert_movie!(&db, 2, 1, Success);
+		assert_movie!(&db, 2, 2, Success);
+
+		have_collection!(&db, 1, 2, Some(1));
+		have_movie!(&db, 1, 3, Some(2));
+		have_show!(&db, 1, 2, Some(2));
+		have_season!(&db, 1, 2, 1);
+		have_episode!(&db, 1, 2, 1, 1);
+		assert_episode!(&db, 2, 1, 1, 1, Success);
+		assert_movie!(&db, 3, 1, Success);
+		have_movie!(&db, 1, 4, Some(2));
+		assert_movie!(&db, 4, 1, Success);
+
+		have_collection!(&db, 1, 3, Some(2));
+		have_movie!(&db, 1, 5, Some(3));
+		assert_movie!(&db, 5, 1, Success);
+		have_movie!(&db, 1, 6, Some(3));
+		assert_movie!(&db, 6, 1, Success);
+		assert_movie!(&db, 6, 2, Success);
+
+		have_collection!(&db, 1, 4, Some(3));
+		have_movie!(&db, 1, 7, Some(4));
+		assert_movie!(&db, 7, 1, Success);
+		assert_movie!(&db, 7, 2, Success);
+		have_movie!(&db, 1, 8, Some(4));
+		assert_movie!(&db, 8, 1, Success);
+		assert_movie!(&db, 8, 2, Success);
+
+		assert_collection!(&db, 1, 1, Watched);
+		assert_collection!(&db, 1, 2, Unwatched);
+		assert_collection!(&db, 2, 1, Watched);
+		assert_collection!(&db, 2, 2, Unwatched);
+		assert_collection!(&db, 3, 1, Watched);
+		assert_collection!(&db, 3, 2, Unwatched);
+		assert_collection!(&db, 4, 1, Watched);
+		assert_collection!(&db, 4, 2, Watched);
+	}
+}

crates/db/src/entity/watched/movies.rs

@@ -0,0 +1,29 @@
+//! Movie entity
+
+use flix_model::id::{MovieId, RawId};
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a watched movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_watched_movies")]
+pub struct Model {
+	/// The movie's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: MovieId,
+	/// The user's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub user_id: RawId,
+	/// The date this movie was watched
+	pub watched_date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/watched/seasons.rs

@@ -0,0 +1,33 @@
+//! Episode entity
+
+use flix_model::id::{RawId, ShowId};
+use flix_model::numbers::SeasonNumber;
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a watched movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_watched_seasons")]
+pub struct Model {
+	/// The season's show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub show: ShowId,
+	/// The season's number
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub season: SeasonNumber,
+	/// The user's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub user_id: RawId,
+	/// The date this season was watched
+	pub watched_date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/entity/watched/shows.rs

@@ -0,0 +1,29 @@
+//! Show entity
+
+use flix_model::id::{RawId, ShowId};
+
+use chrono::NaiveDate;
+use sea_orm::{
+	ActiveModelBehavior, DeriveEntityModel, DerivePrimaryKey, DeriveRelation, EnumIter,
+	PrimaryKeyTrait,
+};
+
+/// The database representation of a watched movie
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "flix_watched_shows")]
+pub struct Model {
+	/// The show's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub id: ShowId,
+	/// The user's ID
+	#[sea_orm(primary_key, auto_increment = false)]
+	pub user_id: RawId,
+	/// The date this show was watched
+	pub watched_date: NaiveDate,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+/// Relation
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}

crates/db/src/lib.rs

@@ -0,0 +1,17 @@
+//! flix-db provides types for storing persistent data about media
+
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+pub mod connection;
+pub mod entity;
+pub mod migration;
+
+#[cfg(test)]
+mod tests {
+	use sea_orm::{ConnectOptions, Database, DatabaseConnection};
+
+	pub async fn new_memory_db() -> DatabaseConnection {
+		let options = ConnectOptions::new("sqlite:/tmp/db?mode=memory");
+		Database::connect(options).await.expect("Database::connect")
+	}
+}

crates/db/src/migration/m_000001.rs

@@ -0,0 +1,53 @@
+//! Adds entity/info tables:
+//!  - Collections
+//!  - Movies
+//!  - Shows
+//!  - Seasons
+//!  - Episodes
+
+use sea_orm::{DbErr, DeriveMigrationName};
+use sea_orm_migration::async_trait;
+use sea_orm_migration::{MigrationTrait, SchemaManager};
+
+mod collections;
+mod episodes;
+mod movies;
+mod seasons;
+mod shows;
+
+#[allow(unused_imports)]
+pub use collections::FlixInfoCollections;
+#[allow(unused_imports)]
+pub use episodes::FlixInfoEpisodes;
+#[allow(unused_imports)]
+pub use movies::FlixInfoMovies;
+#[allow(unused_imports)]
+pub use seasons::FlixInfoSeasons;
+#[allow(unused_imports)]
+pub use shows::FlixInfoShows;
+
+#[derive(DeriveMigrationName)]
+pub(super) struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+	async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		collections::up(manager).await?;
+		movies::up(manager).await?;
+		shows::up(manager).await?;
+		seasons::up(manager).await?;
+		episodes::up(manager).await?;
+
+		Ok(())
+	}
+
+	async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		episodes::down(manager).await?;
+		seasons::down(manager).await?;
+		shows::down(manager).await?;
+		movies::down(manager).await?;
+		collections::down(manager).await?;
+
+		Ok(())
+	}
+}

crates/db/src/migration/m_000001/collections.rs

@@ -0,0 +1,46 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::string;
+
+#[derive(Iden)]
+pub enum FlixInfoCollections {
+	Table,
+	Id,
+	Title,
+	Overview,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixInfoCollections::Table)
+				.col(sqlite_rowid_alias(FlixInfoCollections::Id))
+				.col(string(FlixInfoCollections::Title))
+				.col(string(FlixInfoCollections::Overview))
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_info_collections-title")
+				.table(FlixInfoCollections::Table)
+				.col(FlixInfoCollections::Title)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixInfoCollections::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000001/episodes.rs

@@ -0,0 +1,68 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer, string};
+
+use crate::migration::m_000001::FlixInfoShows;
+
+use super::FlixInfoSeasons;
+
+#[derive(Iden)]
+pub enum FlixInfoEpisodes {
+	Table,
+	Show,
+	Season,
+	Episode,
+	Title,
+	Overview,
+	Date,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixInfoEpisodes::Table)
+				.col(integer(FlixInfoEpisodes::Show))
+				.col(integer(FlixInfoEpisodes::Season))
+				.col(integer(FlixInfoEpisodes::Episode))
+				.col(string(FlixInfoEpisodes::Title))
+				.col(string(FlixInfoEpisodes::Overview))
+				.col(date(FlixInfoEpisodes::Date))
+				.primary_key(
+					Index::create()
+						.col(FlixInfoEpisodes::Show)
+						.col(FlixInfoEpisodes::Season)
+						.col(FlixInfoEpisodes::Episode),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_info_episodes-show")
+						.from_tbl(FlixInfoEpisodes::Table)
+						.from_col(FlixInfoEpisodes::Show)
+						.to_tbl(FlixInfoShows::Table)
+						.to_col(FlixInfoShows::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_info_episodes-show_season")
+						.from_tbl(FlixInfoEpisodes::Table)
+						.from_col(FlixInfoEpisodes::Show)
+						.from_col(FlixInfoEpisodes::Season)
+						.to_tbl(FlixInfoSeasons::Table)
+						.to_col(FlixInfoSeasons::Show)
+						.to_col(FlixInfoSeasons::Season),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixInfoEpisodes::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000001/movies.rs

@@ -0,0 +1,60 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, string};
+
+#[derive(Iden)]
+pub enum FlixInfoMovies {
+	Table,
+	Id,
+	Title,
+	Tagline,
+	Overview,
+	Date,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixInfoMovies::Table)
+				.col(sqlite_rowid_alias(FlixInfoMovies::Id))
+				.col(string(FlixInfoMovies::Title))
+				.col(string(FlixInfoMovies::Tagline))
+				.col(string(FlixInfoMovies::Overview))
+				.col(date(FlixInfoMovies::Date))
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_info_movies-title")
+				.table(FlixInfoMovies::Table)
+				.col(FlixInfoMovies::Title)
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_info_movies-date")
+				.table(FlixInfoMovies::Table)
+				.col(FlixInfoMovies::Date)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixInfoMovies::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000001/seasons.rs

@@ -0,0 +1,53 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer, string};
+
+use super::FlixInfoShows;
+
+#[derive(Iden)]
+pub enum FlixInfoSeasons {
+	Table,
+	Show,
+	Season,
+	Title,
+	Overview,
+	Date,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixInfoSeasons::Table)
+				.col(integer(FlixInfoSeasons::Show))
+				.col(integer(FlixInfoSeasons::Season))
+				.col(string(FlixInfoSeasons::Title))
+				.col(string(FlixInfoSeasons::Overview))
+				.col(date(FlixInfoSeasons::Date))
+				.primary_key(
+					Index::create()
+						.col(FlixInfoSeasons::Show)
+						.col(FlixInfoSeasons::Season),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_info_seasons-show")
+						.from_tbl(FlixInfoSeasons::Table)
+						.from_col(FlixInfoSeasons::Show)
+						.to_tbl(FlixInfoShows::Table)
+						.to_col(FlixInfoShows::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixInfoSeasons::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000001/shows.rs

@@ -0,0 +1,60 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, string};
+
+#[derive(Iden)]
+pub enum FlixInfoShows {
+	Table,
+	Id,
+	Title,
+	Tagline,
+	Overview,
+	Date,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixInfoShows::Table)
+				.col(sqlite_rowid_alias(FlixInfoShows::Id))
+				.col(string(FlixInfoShows::Title))
+				.col(string(FlixInfoShows::Tagline))
+				.col(string(FlixInfoShows::Overview))
+				.col(date(FlixInfoShows::Date))
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_info_shows-title")
+				.table(FlixInfoShows::Table)
+				.col(FlixInfoShows::Title)
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_info_shows-date")
+				.table(FlixInfoShows::Table)
+				.col(FlixInfoShows::Date)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixInfoShows::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000002.rs

@@ -0,0 +1,53 @@
+//! Adds entity/tmdb tables:
+//!  - Collections
+//!  - Movies
+//!  - Shows
+//!  - Seasons
+//!  - Episodes
+
+use sea_orm::{DbErr, DeriveMigrationName};
+use sea_orm_migration::async_trait;
+use sea_orm_migration::{MigrationTrait, SchemaManager};
+
+mod collections;
+mod episodes;
+mod movies;
+mod seasons;
+mod shows;
+
+#[allow(unused_imports)]
+pub use collections::FlixTmdbCollections;
+#[allow(unused_imports)]
+pub use episodes::FlixTmdbEpisodes;
+#[allow(unused_imports)]
+pub use movies::FlixTmdbMovies;
+#[allow(unused_imports)]
+pub use seasons::FlixTmdbSeasons;
+#[allow(unused_imports)]
+pub use shows::FlixTmdbShows;
+
+#[derive(DeriveMigrationName)]
+pub(super) struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+	async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		collections::up(manager).await?;
+		movies::up(manager).await?;
+		shows::up(manager).await?;
+		seasons::up(manager).await?;
+		episodes::up(manager).await?;
+
+		Ok(())
+	}
+
+	async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		episodes::down(manager).await?;
+		seasons::down(manager).await?;
+		shows::down(manager).await?;
+		movies::down(manager).await?;
+		collections::down(manager).await?;
+
+		Ok(())
+	}
+}

crates/db/src/migration/m_000002/collections.rs

@@ -0,0 +1,58 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer};
+
+use super::super::m_000001::FlixInfoCollections;
+
+#[derive(Iden)]
+pub enum FlixTmdbCollections {
+	Table,
+	TmdbId,
+	FlixId,
+	LastUpdate,
+	MovieCount,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixTmdbCollections::Table)
+				.col(sqlite_rowid_alias(FlixTmdbCollections::TmdbId))
+				.col(integer(FlixTmdbCollections::FlixId).unique_key())
+				.col(date(FlixTmdbCollections::LastUpdate))
+				.col(integer(FlixTmdbCollections::MovieCount))
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_collections-flixid")
+						.from_tbl(FlixTmdbCollections::Table)
+						.from_col(FlixTmdbCollections::FlixId)
+						.to_tbl(FlixInfoCollections::Table)
+						.to_col(FlixInfoCollections::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_tmdb_collections-flixid")
+				.table(FlixTmdbCollections::Table)
+				.col(FlixTmdbCollections::FlixId)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixTmdbCollections::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000002/episodes.rs

@@ -0,0 +1,94 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer};
+
+use super::super::m_000001::{FlixInfoEpisodes, FlixInfoSeasons};
+
+use super::FlixTmdbSeasons;
+
+#[derive(Iden)]
+pub enum FlixTmdbEpisodes {
+	Table,
+	TmdbShow,
+	TmdbSeason,
+	TmdbEpisode,
+	FlixShow,
+	FlixSeason,
+	FlixEpisode,
+	LastUpdate,
+	Runtime,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixTmdbEpisodes::Table)
+				.col(integer(FlixTmdbEpisodes::TmdbShow))
+				.col(integer(FlixTmdbEpisodes::TmdbSeason))
+				.col(integer(FlixTmdbEpisodes::TmdbEpisode))
+				.col(integer(FlixTmdbEpisodes::FlixShow))
+				.col(integer(FlixTmdbEpisodes::FlixSeason))
+				.col(integer(FlixTmdbEpisodes::FlixEpisode))
+				.col(date(FlixTmdbEpisodes::LastUpdate))
+				.col(integer(FlixTmdbEpisodes::Runtime))
+				.primary_key(
+					Index::create()
+						.col(FlixTmdbEpisodes::TmdbShow)
+						.col(FlixTmdbEpisodes::TmdbSeason)
+						.col(FlixTmdbEpisodes::TmdbEpisode),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_episodes-tmdb_show_season")
+						.from_tbl(FlixTmdbEpisodes::Table)
+						.from_col(FlixTmdbEpisodes::TmdbShow)
+						.from_col(FlixTmdbEpisodes::TmdbSeason)
+						.to_tbl(FlixTmdbSeasons::Table)
+						.to_col(FlixTmdbSeasons::TmdbShow)
+						.to_col(FlixTmdbSeasons::TmdbSeason),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_episodes-flix_show_season")
+						.from_tbl(FlixTmdbEpisodes::Table)
+						.from_col(FlixTmdbEpisodes::FlixShow)
+						.from_col(FlixTmdbEpisodes::FlixSeason)
+						.to_tbl(FlixInfoSeasons::Table)
+						.to_col(FlixInfoSeasons::Show)
+						.to_col(FlixInfoSeasons::Season),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_episodes-flix_show_season_episode")
+						.from_tbl(FlixTmdbEpisodes::Table)
+						.from_col(FlixTmdbEpisodes::FlixShow)
+						.from_col(FlixTmdbEpisodes::FlixSeason)
+						.from_col(FlixTmdbEpisodes::FlixEpisode)
+						.to_tbl(FlixInfoEpisodes::Table)
+						.to_col(FlixInfoEpisodes::Show)
+						.to_col(FlixInfoEpisodes::Season)
+						.to_col(FlixInfoEpisodes::Episode),
+				)
+				.index(
+					Index::create()
+						.unique()
+						.name("idx-flix_tmdb_episodes-flix_show_season_episode")
+						.col(FlixTmdbEpisodes::FlixShow)
+						.col(FlixTmdbEpisodes::FlixSeason)
+						.col(FlixTmdbEpisodes::FlixEpisode),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixTmdbEpisodes::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000002/movies.rs

@@ -0,0 +1,70 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer, integer_null};
+
+use crate::migration::m_000002::FlixTmdbCollections;
+
+use super::super::m_000001::FlixInfoMovies;
+
+#[derive(Iden)]
+pub enum FlixTmdbMovies {
+	Table,
+	TmdbId,
+	FlixId,
+	LastUpdate,
+	Runtime,
+	Collection,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixTmdbMovies::Table)
+				.col(sqlite_rowid_alias(FlixTmdbMovies::TmdbId))
+				.col(integer(FlixTmdbMovies::FlixId).unique_key())
+				.col(date(FlixTmdbMovies::LastUpdate))
+				.col(integer(FlixTmdbMovies::Runtime))
+				.col(integer_null(FlixTmdbMovies::Collection))
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_movies-flixid")
+						.from_tbl(FlixTmdbMovies::Table)
+						.from_col(FlixTmdbMovies::FlixId)
+						.to_tbl(FlixInfoMovies::Table)
+						.to_col(FlixInfoMovies::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_movies-collectionid")
+						.from_tbl(FlixTmdbMovies::Table)
+						.from_col(FlixTmdbMovies::Collection)
+						.to_tbl(FlixTmdbCollections::Table)
+						.to_col(FlixTmdbCollections::TmdbId),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_tmdb_movies-flixid")
+				.table(FlixTmdbMovies::Table)
+				.col(FlixTmdbMovies::FlixId)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixTmdbMovies::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000002/seasons.rs

@@ -0,0 +1,82 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer};
+
+use crate::migration::m_000001::FlixInfoShows;
+
+use super::super::m_000001::FlixInfoSeasons;
+
+use super::FlixTmdbShows;
+
+#[derive(Iden)]
+pub enum FlixTmdbSeasons {
+	Table,
+	TmdbShow,
+	TmdbSeason,
+	FlixShow,
+	FlixSeason,
+	LastUpdate,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixTmdbSeasons::Table)
+				.col(integer(FlixTmdbSeasons::TmdbShow))
+				.col(integer(FlixTmdbSeasons::TmdbSeason))
+				.col(integer(FlixTmdbSeasons::FlixShow))
+				.col(integer(FlixTmdbSeasons::FlixSeason))
+				.col(date(FlixTmdbSeasons::LastUpdate))
+				.primary_key(
+					Index::create()
+						.col(FlixTmdbSeasons::TmdbShow)
+						.col(FlixTmdbSeasons::TmdbSeason),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_seasons-tmdb_show")
+						.from_tbl(FlixTmdbSeasons::Table)
+						.from_col(FlixTmdbSeasons::FlixShow)
+						.to_tbl(FlixTmdbShows::Table)
+						.to_col(FlixTmdbShows::FlixId),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_seasons-flix_show")
+						.from_tbl(FlixTmdbSeasons::Table)
+						.from_col(FlixTmdbSeasons::FlixShow)
+						.to_tbl(FlixInfoShows::Table)
+						.to_col(FlixInfoShows::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_seasons-flix_show_season")
+						.from_tbl(FlixTmdbSeasons::Table)
+						.from_col(FlixTmdbSeasons::FlixShow)
+						.from_col(FlixTmdbSeasons::FlixSeason)
+						.to_tbl(FlixInfoSeasons::Table)
+						.to_col(FlixInfoSeasons::Show)
+						.to_col(FlixInfoSeasons::Season),
+				)
+				.index(
+					Index::create()
+						.unique()
+						.name("idx-flix_tmdb_seasons-flix_show_season")
+						.col(FlixTmdbSeasons::FlixShow)
+						.col(FlixTmdbSeasons::FlixSeason),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixTmdbSeasons::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000002/shows.rs

@@ -0,0 +1,58 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer};
+
+use super::super::m_000001::FlixInfoShows;
+
+#[derive(Iden)]
+pub enum FlixTmdbShows {
+	Table,
+	TmdbId,
+	FlixId,
+	LastUpdate,
+	NumberOfSeasons,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixTmdbShows::Table)
+				.col(sqlite_rowid_alias(FlixTmdbShows::TmdbId))
+				.col(integer(FlixTmdbShows::FlixId).unique_key())
+				.col(date(FlixTmdbShows::LastUpdate))
+				.col(integer(FlixTmdbShows::NumberOfSeasons))
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_tmdb_shows-flixid")
+						.from_tbl(FlixTmdbShows::Table)
+						.from_col(FlixTmdbShows::FlixId)
+						.to_tbl(FlixInfoShows::Table)
+						.to_col(FlixInfoShows::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	manager
+		.create_index(
+			Index::create()
+				.name("idx-flix_tmdb_shows-flixid")
+				.table(FlixTmdbShows::Table)
+				.col(FlixTmdbShows::FlixId)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixTmdbShows::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000003.rs

@@ -0,0 +1,59 @@
+//! Adds entity/content tables:
+//!  - Libraries
+//!  - Collections
+//!  - Movies
+//!  - Shows
+//!  - Seasons
+//!  - Episodes
+
+use sea_orm::{DbErr, DeriveMigrationName};
+use sea_orm_migration::async_trait;
+use sea_orm_migration::{MigrationTrait, SchemaManager};
+
+mod collections;
+mod episodes;
+mod libraries;
+mod movies;
+mod seasons;
+mod shows;
+
+#[allow(unused_imports)]
+pub use collections::FlixCollections;
+#[allow(unused_imports)]
+pub use episodes::FlixEpisodes;
+#[allow(unused_imports)]
+pub use libraries::FlixLibraries;
+#[allow(unused_imports)]
+pub use movies::FlixMovies;
+#[allow(unused_imports)]
+pub use seasons::FlixSeasons;
+#[allow(unused_imports)]
+pub use shows::FlixShows;
+
+#[derive(DeriveMigrationName)]
+pub(super) struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+	async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		libraries::up(manager).await?;
+		collections::up(manager).await?;
+		movies::up(manager).await?;
+		shows::up(manager).await?;
+		seasons::up(manager).await?;
+		episodes::up(manager).await?;
+
+		Ok(())
+	}
+
+	async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		episodes::down(manager).await?;
+		seasons::down(manager).await?;
+		shows::down(manager).await?;
+		movies::down(manager).await?;
+		collections::down(manager).await?;
+		libraries::down(manager).await?;
+
+		Ok(())
+	}
+}

crates/db/src/migration/m_000003/collections.rs

@@ -0,0 +1,69 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{binary, binary_null, integer, integer_null, string};
+
+use crate::migration::m_000001::FlixInfoCollections;
+use crate::migration::m_000003::FlixLibraries;
+
+#[derive(Iden)]
+pub enum FlixCollections {
+	Table,
+	Id,
+	Parent,
+	Slug,
+	Library,
+	Directory,
+	RelativePosterPath,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixCollections::Table)
+				.col(sqlite_rowid_alias(FlixCollections::Id))
+				.col(integer_null(FlixCollections::Parent))
+				.col(string(FlixCollections::Slug))
+				.col(integer(FlixCollections::Library))
+				.col(binary(FlixCollections::Directory))
+				.col(binary_null(FlixCollections::RelativePosterPath))
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_collections-id")
+						.from_tbl(FlixCollections::Table)
+						.from_col(FlixCollections::Id)
+						.to_tbl(FlixInfoCollections::Table)
+						.to_col(FlixInfoCollections::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_collections-parent")
+						.from_tbl(FlixCollections::Table)
+						.from_col(FlixCollections::Parent)
+						.to_tbl(FlixCollections::Table)
+						.to_col(FlixCollections::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_collections-library")
+						.from_tbl(FlixCollections::Table)
+						.from_col(FlixCollections::Library)
+						.to_tbl(FlixLibraries::Table)
+						.to_col(FlixLibraries::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixCollections::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000003/episodes.rs

@@ -0,0 +1,73 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{binary, binary_null, integer, string};
+
+use crate::migration::m_000001::FlixInfoEpisodes;
+use crate::migration::m_000003::FlixLibraries;
+
+#[derive(Iden)]
+pub enum FlixEpisodes {
+	Table,
+	Show,
+	Season,
+	Episode,
+	Slug,
+	Library,
+	Directory,
+	RelativeMediaPath,
+	RelativePosterPath,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixEpisodes::Table)
+				.col(integer(FlixEpisodes::Show))
+				.col(integer(FlixEpisodes::Season))
+				.col(integer(FlixEpisodes::Episode))
+				.col(string(FlixEpisodes::Slug))
+				.col(integer(FlixEpisodes::Library))
+				.col(binary(FlixEpisodes::Directory))
+				.col(binary(FlixEpisodes::RelativeMediaPath))
+				.col(binary_null(FlixEpisodes::RelativePosterPath))
+				.primary_key(
+					Index::create()
+						.col(FlixEpisodes::Show)
+						.col(FlixEpisodes::Season)
+						.col(FlixEpisodes::Episode),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_episodes-show_season_episode")
+						.from_tbl(FlixEpisodes::Table)
+						.from_col(FlixEpisodes::Show)
+						.from_col(FlixEpisodes::Season)
+						.from_col(FlixEpisodes::Episode)
+						.to_tbl(FlixInfoEpisodes::Table)
+						.to_col(FlixInfoEpisodes::Show)
+						.to_col(FlixInfoEpisodes::Season)
+						.to_col(FlixInfoEpisodes::Episode),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_episodes-library")
+						.from_tbl(FlixEpisodes::Table)
+						.from_col(FlixEpisodes::Library)
+						.to_tbl(FlixLibraries::Table)
+						.to_col(FlixLibraries::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixEpisodes::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000003/libraries.rs

@@ -0,0 +1,34 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::Table;
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::binary;
+
+#[derive(Iden)]
+pub enum FlixLibraries {
+	Table,
+	Id,
+	Directory,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixLibraries::Table)
+				.col(sqlite_rowid_alias(FlixLibraries::Id))
+				.col(binary(FlixLibraries::Directory))
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixLibraries::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000003/movies.rs

@@ -0,0 +1,71 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{binary, binary_null, integer, integer_null, string};
+
+use crate::migration::m_000001::FlixInfoMovies;
+use crate::migration::m_000003::{FlixCollections, FlixLibraries};
+
+#[derive(Iden)]
+pub enum FlixMovies {
+	Table,
+	Id,
+	Parent,
+	Slug,
+	Library,
+	Directory,
+	RelativeMediaPath,
+	RelativePosterPath,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixMovies::Table)
+				.col(sqlite_rowid_alias(FlixMovies::Id))
+				.col(integer_null(FlixMovies::Parent))
+				.col(string(FlixMovies::Slug))
+				.col(integer(FlixMovies::Library))
+				.col(binary(FlixMovies::Directory))
+				.col(binary(FlixMovies::RelativeMediaPath))
+				.col(binary_null(FlixMovies::RelativePosterPath))
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_movies-id")
+						.from_tbl(FlixMovies::Table)
+						.from_col(FlixMovies::Id)
+						.to_tbl(FlixInfoMovies::Table)
+						.to_col(FlixInfoMovies::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_movies-parent")
+						.from_tbl(FlixMovies::Table)
+						.from_col(FlixMovies::Parent)
+						.to_tbl(FlixCollections::Table)
+						.to_col(FlixCollections::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_movies-library")
+						.from_tbl(FlixMovies::Table)
+						.from_col(FlixMovies::Library)
+						.to_tbl(FlixLibraries::Table)
+						.to_col(FlixLibraries::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixMovies::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000003/seasons.rs

@@ -0,0 +1,66 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{binary, binary_null, integer, string};
+
+use crate::migration::m_000001::FlixInfoSeasons;
+use crate::migration::m_000003::FlixLibraries;
+
+#[derive(Iden)]
+pub enum FlixSeasons {
+	Table,
+	Show,
+	Season,
+	Slug,
+	Library,
+	Directory,
+	RelativePosterPath,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixSeasons::Table)
+				.col(integer(FlixSeasons::Show))
+				.col(integer(FlixSeasons::Season))
+				.col(string(FlixSeasons::Slug))
+				.col(integer(FlixSeasons::Library))
+				.col(binary(FlixSeasons::Directory))
+				.col(binary_null(FlixSeasons::RelativePosterPath))
+				.primary_key(
+					Index::create()
+						.col(FlixSeasons::Show)
+						.col(FlixSeasons::Season),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_seasons-show_season")
+						.from_tbl(FlixSeasons::Table)
+						.from_col(FlixSeasons::Show)
+						.from_col(FlixSeasons::Season)
+						.to_tbl(FlixInfoSeasons::Table)
+						.to_col(FlixInfoSeasons::Show)
+						.to_col(FlixInfoSeasons::Season),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_seasons-library")
+						.from_tbl(FlixSeasons::Table)
+						.from_col(FlixSeasons::Library)
+						.to_tbl(FlixLibraries::Table)
+						.to_col(FlixLibraries::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixSeasons::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000003/shows.rs

@@ -0,0 +1,69 @@
+use seamantic::schema::sqlite_rowid_alias;
+
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{binary, binary_null, integer, integer_null, string};
+
+use crate::migration::m_000001::FlixInfoShows;
+use crate::migration::m_000003::{FlixCollections, FlixLibraries};
+
+#[derive(Iden)]
+pub enum FlixShows {
+	Table,
+	Id,
+	Parent,
+	Slug,
+	Library,
+	Directory,
+	RelativePosterPath,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixShows::Table)
+				.col(sqlite_rowid_alias(FlixShows::Id))
+				.col(integer_null(FlixShows::Parent))
+				.col(string(FlixShows::Slug))
+				.col(integer(FlixShows::Library))
+				.col(binary(FlixShows::Directory))
+				.col(binary_null(FlixShows::RelativePosterPath))
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_shows-id")
+						.from_tbl(FlixShows::Table)
+						.from_col(FlixShows::Id)
+						.to_tbl(FlixInfoShows::Table)
+						.to_col(FlixInfoShows::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_shows-parent")
+						.from_tbl(FlixShows::Table)
+						.from_col(FlixShows::Parent)
+						.to_tbl(FlixCollections::Table)
+						.to_col(FlixCollections::Id),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_shows-library")
+						.from_tbl(FlixShows::Table)
+						.from_col(FlixShows::Library)
+						.to_tbl(FlixLibraries::Table)
+						.to_col(FlixLibraries::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixShows::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000004.rs

@@ -0,0 +1,47 @@
+//! Adds entity/watched tables:
+//!  - Collections
+//!  - Movies
+//!  - Shows
+//!  - Seasons
+//!  - Episodes
+
+use sea_orm::{DbErr, DeriveMigrationName};
+use sea_orm_migration::async_trait;
+use sea_orm_migration::{MigrationTrait, SchemaManager};
+
+mod collections;
+mod episodes;
+mod movies;
+mod seasons;
+mod shows;
+
+#[allow(unused_imports)]
+pub use episodes::FlixWatchedEpisodes;
+#[allow(unused_imports)]
+pub use movies::FlixWatchedMovies;
+
+#[derive(DeriveMigrationName)]
+pub(super) struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+	async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		episodes::up(manager).await?;
+		seasons::up(manager).await?;
+		shows::up(manager).await?;
+		movies::up(manager).await?;
+		collections::up(manager).await?;
+
+		Ok(())
+	}
+
+	async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+		collections::down(manager).await?;
+		movies::down(manager).await?;
+		shows::down(manager).await?;
+		seasons::down(manager).await?;
+		episodes::down(manager).await?;
+
+		Ok(())
+	}
+}

crates/db/src/migration/m_000004/collections.rs

@@ -0,0 +1,98 @@
+use sea_orm::DbErr;
+use sea_orm::{ConnectionTrait, DbBackend, Statement};
+use sea_orm_migration::SchemaManager;
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.get_connection()
+		.execute_raw(Statement::from_string(
+			DbBackend::Sqlite,
+			r#"
+				CREATE VIEW flix_watched_collections AS
+				WITH RECURSIVE
+				watched_items AS (
+					SELECT
+						w.id,
+						w.user_id,
+						w.watched_date,
+						'movie' AS type
+					FROM flix_watched_movies w
+
+					UNION ALL
+
+					SELECT
+						w.id,
+						w.user_id,
+						w.watched_date,
+						'show' AS type
+					FROM flix_watched_shows w
+				),
+				collection_items AS (
+					SELECT
+						m.parent,
+						m.id,
+						'movie' AS type
+					FROM flix_movies m
+					WHERE m.parent IS NOT NULL
+
+					UNION ALL
+
+					SELECT
+						s.parent,
+						s.id,
+						'show' AS type
+					FROM flix_shows s
+					WHERE s.parent IS NOT NULL
+
+					UNION ALL
+
+					SELECT
+						c.parent,
+						ci.id,
+						ci.type
+					FROM collection_items ci
+					JOIN flix_collections c
+						ON c.id = ci.parent
+				)
+				SELECT
+					ci.parent AS id,
+					wi.user_id,
+					MAX(wi.watched_date) AS watched_date
+				FROM collection_items ci
+				JOIN watched_items wi
+					ON wi.id = ci.id
+					AND wi.type = ci.type
+				WHERE NOT EXISTS (
+					SELECT 1
+					FROM collection_items ci2
+					WHERE ci2.parent = ci.parent
+					AND NOT EXISTS (
+						SELECT 1
+						FROM watched_items wi2
+						WHERE wi2.id = ci2.id
+						AND wi2.type = ci2.type
+						AND wi2.user_id = wi.user_id
+					)
+				)
+				GROUP BY ci.parent, wi.user_id;
+			"#,
+		))
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.get_connection()
+		.execute_raw(Statement::from_string(
+			DbBackend::Sqlite,
+			r#"
+				DROP VIEW flix_watched_collections
+				;
+			"#,
+		))
+		.await?;
+
+	Ok(())
+}

crates/db/src/migration/m_000004/episodes.rs

@@ -0,0 +1,60 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer};
+
+use crate::migration::m_000001::FlixInfoEpisodes;
+
+#[derive(Iden)]
+pub enum FlixWatchedEpisodes {
+	Table,
+	Show,
+	Season,
+	Episode,
+	UserId,
+	WatchedDate,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixWatchedEpisodes::Table)
+				.col(integer(FlixWatchedEpisodes::Show))
+				.col(integer(FlixWatchedEpisodes::Season))
+				.col(integer(FlixWatchedEpisodes::Episode))
+				.col(integer(FlixWatchedEpisodes::UserId))
+				.col(date(FlixWatchedEpisodes::WatchedDate))
+				.primary_key(
+					Index::create()
+						.col(FlixWatchedEpisodes::Show)
+						.col(FlixWatchedEpisodes::Season)
+						.col(FlixWatchedEpisodes::Episode)
+						.col(FlixWatchedEpisodes::UserId),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_watched_episodes-show_season_episode")
+						.from_tbl(FlixWatchedEpisodes::Table)
+						.from_tbl(FlixWatchedEpisodes::Table)
+						.from_col(FlixWatchedEpisodes::Show)
+						.from_col(FlixWatchedEpisodes::Season)
+						.from_col(FlixWatchedEpisodes::Episode)
+						.to_tbl(FlixInfoEpisodes::Table)
+						.to_col(FlixInfoEpisodes::Show)
+						.to_col(FlixInfoEpisodes::Season)
+						.to_col(FlixInfoEpisodes::Episode),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixWatchedEpisodes::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000004/movies.rs

@@ -0,0 +1,49 @@
+use sea_orm::sea_query;
+use sea_orm::sea_query::{ForeignKeyCreateStatement, Index, Table};
+use sea_orm::{DbErr, Iden};
+use sea_orm_migration::SchemaManager;
+use sea_orm_migration::schema::{date, integer};
+
+use crate::migration::m_000001::FlixInfoMovies;
+
+#[derive(Iden)]
+pub enum FlixWatchedMovies {
+	Table,
+	Id,
+	UserId,
+	WatchedDate,
+}
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.create_table(
+			Table::create()
+				.table(FlixWatchedMovies::Table)
+				.col(integer(FlixWatchedMovies::Id))
+				.col(integer(FlixWatchedMovies::UserId))
+				.col(date(FlixWatchedMovies::WatchedDate))
+				.primary_key(
+					Index::create()
+						.col(FlixWatchedMovies::Id)
+						.col(FlixWatchedMovies::UserId),
+				)
+				.foreign_key(
+					ForeignKeyCreateStatement::new()
+						.name("fk-flix_watched_movies-id")
+						.from_tbl(FlixWatchedMovies::Table)
+						.from_col(FlixWatchedMovies::Id)
+						.to_tbl(FlixInfoMovies::Table)
+						.to_col(FlixInfoMovies::Id),
+				)
+				.to_owned(),
+		)
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.drop_table(Table::drop().table(FlixWatchedMovies::Table).to_owned())
+		.await
+}

crates/db/src/migration/m_000004/seasons.rs

@@ -0,0 +1,54 @@
+use sea_orm::DbErr;
+use sea_orm::{ConnectionTrait, DbBackend, Statement};
+use sea_orm_migration::SchemaManager;
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.get_connection()
+		.execute_raw(Statement::from_string(
+			DbBackend::Sqlite,
+			r#"
+				CREATE VIEW flix_watched_seasons AS
+				SELECT
+					w.show,
+					w.season,
+					w.user_id,
+					MAX(w.watched_date) AS watched_date
+				FROM flix_watched_episodes w
+				WHERE NOT EXISTS (
+					SELECT 1
+					FROM flix_episodes e
+					WHERE e.show = w.show
+					AND e.season = w.season
+					AND NOT EXISTS (
+						SELECT 1
+						FROM flix_watched_episodes wc
+						WHERE wc.show = e.show
+						AND wc.season = e.season
+						AND wc.episode = e.episode
+						AND wc.user_id = w.user_id
+					)
+				)
+				GROUP BY w.show, w.season, w.user_id
+				;
+			"#,
+		))
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.get_connection()
+		.execute_raw(Statement::from_string(
+			DbBackend::Sqlite,
+			r#"
+				DROP VIEW flix_watched_seasons
+				;
+			"#,
+		))
+		.await?;
+
+	Ok(())
+}

crates/db/src/migration/m_000004/shows.rs

@@ -0,0 +1,51 @@
+use sea_orm::DbErr;
+use sea_orm::{ConnectionTrait, DbBackend, Statement};
+use sea_orm_migration::SchemaManager;
+
+pub async fn up(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.get_connection()
+		.execute_raw(Statement::from_string(
+			DbBackend::Sqlite,
+			r#"
+				CREATE VIEW flix_watched_shows AS
+				SELECT
+					w.show as id,
+					w.user_id,
+					MAX(w.watched_date) AS watched_date
+				FROM flix_watched_seasons w
+				WHERE NOT EXISTS (
+					SELECT 1
+					FROM flix_seasons s
+					WHERE s.show = w.show
+					AND NOT EXISTS (
+						SELECT 1
+						FROM flix_watched_seasons wc
+						WHERE wc.show = s.show
+						AND wc.season = s.season
+						AND wc.user_id = w.user_id
+					)
+				)
+				GROUP BY w.show, w.user_id
+				;
+			"#,
+		))
+		.await?;
+
+	Ok(())
+}
+
+pub async fn down(manager: &SchemaManager<'_>) -> Result<(), DbErr> {
+	manager
+		.get_connection()
+		.execute_raw(Statement::from_string(
+			DbBackend::Sqlite,
+			r#"
+				DROP VIEW flix_watched_shows
+				;
+			"#,
+		))
+		.await?;
+
+	Ok(())
+}

crates/db/src/migration/mod.rs

@@ -0,0 +1,9 @@
+//! Migrations for maintaining the database schema
+
+seamantic::migrations! {
+	"seaql_migrations_flix";
+	m_000001,
+	m_000002,
+	m_000003,
+	m_000004,
+}