Rework database model to be more flexible

.vscode/extensions.json

@@ -1,9 +0,0 @@
-{
-	"recommendations": [
-		"vadimcn.vscode-lldb",
-		"barbosshack.crates-io",
-		"usernamehw.errorlens",
-		"tamasfe.even-better-toml",
-		"rust-lang.rust-analyzer",
-	]
-}

.vscode/settings.json

@@ -1,33 +0,0 @@
-{
-	// VSCode
-	"editor.detectIndentation": false,
-	"editor.insertSpaces": false,
-	"editor.tabSize": 4,
-	"files.exclude": {
-		"**/target": true,
-		"**/Cargo.lock": true,
-	},
-	"files.insertFinalNewline": true,
-	"files.trimFinalNewlines": true,
-	"files.trimTrailingWhitespace": true,
-	"files.watcherExclude": {
-		"**/.git/**": true,
-		"**/target/**": true,
-	},
-	// Extensions
-	"crates.listPreReleases": true,
-	"evenBetterToml.formatter.alignComments": true,
-	"evenBetterToml.formatter.alignEntries": false,
-	"evenBetterToml.formatter.allowedBlankLines": 1,
-	"evenBetterToml.formatter.arrayAutoExpand": true,
-	"evenBetterToml.formatter.arrayTrailingComma": true,
-	"evenBetterToml.formatter.columnWidth": 80,
-	"evenBetterToml.formatter.reorderKeys": true,
-	"evenBetterToml.formatter.trailingNewline": true,
-	"rust-analyzer.imports.granularity.enforce": true,
-	"rust-analyzer.imports.granularity.group": "module",
-	"rust-analyzer.imports.group.enable": true,
-	"rust-analyzer.imports.merge.glob": false,
-	"rust-analyzer.imports.preferNoStd": true,
-	"rust-analyzer.showUnlinkedFileNotification": false,
-}

.zed/settings.json

@@ -0,0 +1,33 @@
+{
+	"project_name": null,
+
+	"auto_install_extensions": {
+		"tombi": true,
+		"cargo-appraiser": true,
+	},
+
+	"languages": {
+		"TOML": {
+			"format_on_save": "on",
+			"formatter": { "language_server": { "name": "tombi" } },
+		},
+	},
+
+	"lsp": {
+		"rust-analyzer": {
+			"initialization_options": {
+				"imports": {
+					"granularity": { "enforce": true, "group": "module" },
+					"group": { "enable": true },
+					"merge": { "glob": false },
+					"preferNoStd": true,
+				},
+				"server": {
+					"extraEnv": {
+						"RUSTUP_TOOLCHAIN": "stable",
+					},
+				},
+			},
+		},
+	},
+}

Cargo.toml

@@ -1,18 +1,42 @@
 [workspace]
-members = ["crates/*"]
 resolver = "2"
+members = ["crates/*"]
 
 [workspace.package]
-authors = []
 edition = "2024"
+rust-version = "1.87.0"
 license-file = "LICENSE.md"
-rust-version = "1.85.0"
 
-[workspace.lints.rust]
+[workspace.dependencies]
-arithmetic_overflow = "forbid"
+anyhow = { version = "^1", default-features = false }
-missing_docs = "forbid"
+async-stream = { version = "^0.3", default-features = false }
-unsafe_code = "forbid"
+chrono = { version = "^0.4", default-features = false }
-unused_doc_comments = "forbid"
+clap = { version = "^4", default-features = false }
+flix = { path = "crates/flix", version = "=0.0.16", default-features = false }
+flix-cli = { path = "crates/cli", version = "=0.0.16", default-features = false }
+flix-db = { path = "crates/db", version = "=0.0.16", default-features = false }
+flix-fs = { path = "crates/fs", version = "=0.0.16", default-features = false }
+flix-model = { path = "crates/model", version = "=0.0.16", default-features = false }
+flix-tmdb = { path = "crates/tmdb", version = "=0.0.16", default-features = false }
+futures = { version = "^0.3", default-features = false }
+governor = { version = "^0.10", default-features = false }
+itertools = { version = "^0.14", default-features = false }
+nonzero_ext = { version = "^0.3", default-features = false }
+regex = { version = "^1", default-features = false }
+reqwest = { version = "^0.13", default-features = false }
+sea-orm = { version = "2.0.0-rc.27", default-features = false }
+sea-orm-migration = { version = "2.0.0-rc.27", default-features = false }
+seamantic = { version = "^0.0.11", default-features = false }
+serde = { version = "^1", default-features = false }
+serde_test = { version = "^1", default-features = false }
+thiserror = { version = "^2", default-features = false }
+tokio = { version = "^1", default-features = false }
+tokio-stream = { version = "^0.1", default-features = false }
+toml = { version = "^0.9", default-features = false }
+tracing = { version = "^0.1", default-features = false }
+tracing-subscriber = { version = "^0.3", default-features = false }
+url = { version = "^2", default-features = false }
+url-macro = { version = "^0.2", default-features = false }
 
 [workspace.lints.clippy]
 arithmetic_side_effects = "forbid"
@@ -24,45 +48,18 @@ indexing_slicing = "forbid"
 integer_division = "forbid"
 integer_division_remainder_used = "forbid"
 transmute_undefined_repr = "forbid"
-unchecked_duration_subtraction = "forbid"
+unchecked_time_subtraction = "forbid"
 unwrap_used = "forbid"
 
+[workspace.lints.rust]
+arithmetic_overflow = "forbid"
+missing_docs = "forbid"
+unsafe_code = "forbid"
+unused_doc_comments = "forbid"
+
 [profile.release]
-codegen-units = 1
-lto = "fat"
 opt-level = 3
-overflow-checks = true
 strip = "debuginfo"
-
+overflow-checks = true
-[workspace.dependencies]
+lto = "fat"
-flix = { path = "crates/flix", version = "=0.0.14", default-features = false }
+codegen-units = 1
-flix-cli = { path = "crates/cli", version = "=0.0.14", default-features = false }
-flix-db = { path = "crates/db", version = "=0.0.14", default-features = false }
-flix-fs = { path = "crates/fs", version = "=0.0.14", default-features = false }
-flix-model = { path = "crates/model", version = "=0.0.14", default-features = false }
-flix-tmdb = { path = "crates/tmdb", version = "=0.0.14", default-features = false }
-
-seamantic = { version = "0.0.10", default-features = false }
-
-sea-orm = { version = "2.0.0-rc.17", default-features = false }
-sea-orm-migration = { version = "2.0.0-rc.17", default-features = false }
-
-anyhow = { version = "^1", default-features = false }
-async-stream = { version = "^0.3", default-features = false }
-chrono = { version = "^0.4", default-features = false }
-clap = { version = "^4", default-features = false, features = ["std"] }
-futures = { version = "^0.3", default-features = false }
-governor = { version = "^0.10", default-features = false }
-nonzero_ext = { version = "^0.3", default-features = false }
-regex = { version = "^1", default-features = false }
-reqwest = { version = "^0.12", default-features = false }
-serde = { version = "^1", default-features = false }
-serde_test = { version = "^1", default-features = false }
-thiserror = { version = "^2", default-features = false }
-tokio = { version = "^1", default-features = false }
-tokio-stream = { version = "^0.1", default-features = false }
-toml = { version = "^0.9", default-features = false }
-tracing = { version = "^0.1", default-features = false }
-tracing-subscriber = { version = "^0.3", default-features = false }
-url = { version = "^2", default-features = false }
-url-macro = { version = "^0.2", default-features = false }

README.md

@@ -7,7 +7,7 @@ Libraries and tools for dealing with media metadata
 - build: `cargo hack --feature-powerset build`
 - clippy: `cargo hack --feature-powerset clippy -- -D warnings`
 - test: `cargo hack --feature-powerset test`
-- test old: `cargo +1.85 hack --feature-powerset test`
+- test old: `cargo +1.87 hack --feature-powerset test`
 - fmt: `cargo fmt --check`
 - docs: `RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features`
 - install: `cargo install --path crates/cli`

crates/cli/Cargo.toml

@@ -1,15 +1,12 @@
 [package]
 name = "flix-cli"
-version = "0.0.14"
+version = "0.0.16"
-
+edition.workspace = true
-categories = ["command-line-utilities"]
+rust-version.workspace = true
 description = "CLI for interacting with a flix database"
 repository = "https://github.com/QuantumShade/flix"
-
-authors.workspace = true
-edition.workspace = true
 license-file.workspace = true
-rust-version.workspace = true
+categories = ["command-line-utilities"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -20,9 +17,26 @@ doc = false
 name = "flix"
 path = "src/main.rs"
 
-[lints.rust]
+[dependencies]
-arithmetic_overflow = "forbid"
+anyhow = { workspace = true }
-unsafe_code = "forbid"
+chrono = { workspace = true, features = ["now"] }
+clap = { workspace = true, features = [
+	"color",
+	"derive",
+	"error-context",
+	"help",
+	"std",
+	"suggestions",
+	"usage",
+] }
+flix = { workspace = true, features = ["tmdb"] }
+futures = { workspace = true }
+sea-orm = { workspace = true, features = ["debug-print", "runtime-tokio"] }
+serde = { workspace = true, features = ["derive"] }
+tokio = { workspace = true, features = ["fs", "macros", "rt"] }
+toml = { workspace = true, features = ["parse", "serde"] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [lints.clippy]
 arithmetic_side_effects = "deny"
@@ -34,26 +48,9 @@ indexing_slicing = "deny"
 integer_division = "deny"
 integer_division_remainder_used = "deny"
 transmute_undefined_repr = "deny"
-unchecked_duration_subtraction = "deny"
+unchecked_time_subtraction = "deny"
 unwrap_used = "deny"
 
-[dependencies]
+[lints.rust]
-flix = { workspace = true, features = ["tmdb"] }
+arithmetic_overflow = "forbid"
-
+unsafe_code = "forbid"
-anyhow = { workspace = true }
-chrono = { workspace = true, features = ["now"] }
-clap = { workspace = true, features = [
-	"derive",
-	"color",
-	"error-context",
-	"help",
-	"suggestions",
-	"usage",
-] }
-futures = { workspace = true }
-sea-orm = { workspace = true, features = ["runtime-tokio", "debug-print"] }
-serde = { workspace = true, features = ["derive"] }
-tokio = { workspace = true, features = ["rt", "fs", "macros"] }
-toml = { workspace = true, features = ["parse", "serde"] }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }

crates/cli/src/cli/flix.rs

@@ -0,0 +1,12 @@
+use clap::Subcommand;
+
+#[derive(Subcommand)]
+pub enum AddCommand {
+	/// Process a flix collection
+	Collection {
+		#[arg(value_name = "TITLE")]
+		title: String,
+		#[arg(value_name = "OVERVIEW")]
+		overview: String,
+	},
+}

crates/cli/src/cli/mod.rs

@@ -3,6 +3,7 @@ use std::path::PathBuf;
 use anyhow::{Result, anyhow};
 use clap::{Parser, Subcommand};
 
+pub mod flix;
 pub mod tmdb;
 
 #[derive(Parser)]
@@ -57,17 +58,17 @@ pub enum Command {
 	/// Add new items to the database
 	Add {
 		#[command(subcommand)]
-		command: BackendCommand,
+		command: AddCommand,
 	},
 	/// Update an existing item in the database
 	Update {
 		#[command(subcommand)]
-		command: BackendCommand,
+		command: UpdateCommand,
 	},
 	/// Delete an existing item in the database
 	Delete {
 		#[command(subcommand)]
-		command: BackendCommand,
+		command: DeleteCommand,
 	},
 	/// Create a toml backup of the database
 	Backup {
@@ -84,7 +85,12 @@ pub enum Command {
 }
 
 #[derive(Subcommand)]
-pub enum BackendCommand {
+pub enum AddCommand {
+	/// Use the flix backend
+	Flix {
+		#[command(subcommand)]
+		command: flix::AddCommand,
+	},
 	/// Use the TMDB backend
 	Tmdb {
 		#[command(subcommand)]
@@ -92,7 +98,43 @@ pub enum BackendCommand {
 	},
 }
 
-impl From<tmdb::Command> for BackendCommand {
+impl From<flix::AddCommand> for AddCommand {
+	fn from(value: flix::AddCommand) -> Self {
+		Self::Flix { command: value }
+	}
+}
+
+impl From<tmdb::Command> for AddCommand {
+	fn from(value: tmdb::Command) -> Self {
+		Self::Tmdb { command: value }
+	}
+}
+
+#[derive(Subcommand)]
+pub enum UpdateCommand {
+	/// Use the TMDB backend
+	Tmdb {
+		#[command(subcommand)]
+		command: tmdb::Command,
+	},
+}
+
+impl From<tmdb::Command> for UpdateCommand {
+	fn from(value: tmdb::Command) -> Self {
+		Self::Tmdb { command: value }
+	}
+}
+
+#[derive(Subcommand)]
+pub enum DeleteCommand {
+	/// Use the TMDB backend
+	Tmdb {
+		#[command(subcommand)]
+		command: tmdb::Command,
+	},
+}
+
+impl From<tmdb::Command> for DeleteCommand {
 	fn from(value: tmdb::Command) -> Self {
 		Self::Tmdb { command: value }
 	}

crates/cli/src/lib.rs

@@ -1,3 +0,0 @@
-//! Placeholder
-
-#![cfg_attr(docsrs, feature(doc_cfg))]

crates/cli/src/main.rs

@@ -7,7 +7,7 @@ use clap::Parser;
 use tokio::fs;
 
 mod cli;
-use cli::{BackendCommand, Cli, Command};
+use cli::{AddCommand, Cli, Command, DeleteCommand, UpdateCommand};
 
 mod config;
 use config::Config;
@@ -53,11 +53,14 @@ async fn exec_init(database_path: String) -> Result<()> {
 	Ok(())
 }
 
-async fn exec_add(client: Client, database_path: String, command: BackendCommand) -> Result<()> {
+async fn exec_add(client: Client, database_path: String, command: AddCommand) -> Result<()> {
 	let database = db::open(database_path).await?;
 
 	match command {
-		BackendCommand::Tmdb { command } => {
+		AddCommand::Flix { command } => {
+			run::flix::add(database.as_ref(), command).await?;
+		}
+		AddCommand::Tmdb { command } => {
 			run::tmdb::add(client, database.as_ref(), command).await?;
 		}
 	}
@@ -65,11 +68,11 @@ async fn exec_add(client: Client, database_path: String, command: BackendCommand
 	Ok(())
 }
 
-async fn exec_update(client: Client, database_path: String, command: BackendCommand) -> Result<()> {
+async fn exec_update(client: Client, database_path: String, command: UpdateCommand) -> Result<()> {
 	let database = db::open(database_path).await?;
 
 	match command {
-		BackendCommand::Tmdb { command } => {
+		UpdateCommand::Tmdb { command } => {
 			run::tmdb::update(client, database.as_ref(), command).await?;
 		}
 	}
@@ -77,16 +80,11 @@ async fn exec_update(client: Client, database_path: String, command: BackendComm
 	Ok(())
 }
 
-async fn exec_delete(client: Client, database_path: String, command: BackendCommand) -> Result<()> {
+async fn exec_delete(client: Client, database_path: String, command: DeleteCommand) -> Result<()> {
-	let database = db::open(database_path).await?;
+	_ = client;
-
+	_ = database_path;
-	match command {
+	_ = command;
-		BackendCommand::Tmdb { command } => {
+	unimplemented!()
-			run::tmdb::delete(client, database.as_ref(), command).await?;
-		}
-	}
-
-	Ok(())
 }
 
 async fn exec_backup(database_path: String, output: PathBuf) -> Result<()> {

crates/cli/src/run/flix.rs

@@ -0,0 +1,49 @@
+use flix::db::entity;
+use flix::model::id::CollectionId;
+use flix::model::text;
+
+use anyhow::Result;
+use sea_orm::ActiveValue::{NotSet, Set};
+use sea_orm::{ActiveModelTrait, DatabaseConnection, DbErr, TransactionError, TransactionTrait};
+
+use crate::cli::flix::AddCommand;
+
+pub async fn add(db: &DatabaseConnection, command: AddCommand) -> Result<()> {
+	match command {
+		AddCommand::Collection { title, overview } => {
+			let result: Result<CollectionId, TransactionError<DbErr>> = db
+				.transaction(|txn| {
+					let title = title.clone();
+
+					let sort_title = text::make_sortable_title(&title);
+					let fs_slug = text::make_fs_slug(&title);
+					let web_slug = text::make_web_slug(&title);
+
+					Box::pin(async move {
+						let flix = entity::info::collections::ActiveModel {
+							id: NotSet,
+							title: Set(title),
+							overview: Set(overview),
+							sort_title: Set(sort_title),
+							fs_slug: Set(fs_slug),
+							web_slug: Set(web_slug),
+						}
+						.insert(txn)
+						.await?;
+
+						Ok(flix.id)
+					})
+				})
+				.await;
+
+			let flix_id = match result {
+				Ok(id) => id,
+				Err(TransactionError::Connection(err)) => Err(err)?,
+				Err(TransactionError::Transaction(err)) => Err(err)?,
+			};
+			println!("Created Collection: {} [{}]", title, flix_id.into_raw());
+
+			Ok(())
+		}
+	}
+}

crates/cli/src/run/mod.rs

@@ -1 +1,2 @@
+pub mod flix;
 pub mod tmdb;

crates/cli/src/run/tmdb.rs

@@ -3,13 +3,14 @@ use std::collections::HashMap;
 use flix::db::entity;
 use flix::model::id::{CollectionId, MovieId, ShowId};
 use flix::model::numbers::{EpisodeNumber, SeasonNumber};
+use flix::model::text;
 use flix::tmdb::Client;
 use flix::tmdb::model::id::{
 	CollectionId as TmdbCollectionId, MovieId as TmdbMovieId, ShowId as TmdbShowId,
 };
 
 use anyhow::{Context, Result, bail};
-use chrono::Utc;
+use chrono::{Datelike, Utc};
 use sea_orm::ActiveValue::{NotSet, Set};
 use sea_orm::{
 	ActiveModelTrait, DatabaseConnection, DbErr, EntityTrait, TransactionError, TransactionTrait,
@@ -35,6 +36,12 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				.await
 				.with_context(|| format!("collections().get_details({})", id.into_raw()))?;
 
+			let title = collection.title.clone();
+
+			let sort_title = text::make_sortable_title(&title);
+			let fs_slug = text::make_fs_slug(&title);
+			let web_slug = text::make_web_slug(&title);
+
 			let result: Result<CollectionId, TransactionError<DbErr>> = db
 				.transaction(|txn| {
 					Box::pin(async move {
@@ -42,6 +49,9 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 							id: NotSet,
 							title: Set(collection.title),
 							overview: Set(collection.overview),
+							sort_title: Set(sort_title),
+							fs_slug: Set(fs_slug),
+							web_slug: Set(web_slug),
 						}
 						.insert(txn)
 						.await?;
@@ -49,7 +59,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 						entity::tmdb::collections::ActiveModel {
 							tmdb_id: Set(id),
 							flix_id: Set(flix.id),
-							last_update: Set(Utc::now().naive_utc().date()),
+							last_update: Set(Utc::now()),
 							movie_count: Set(collection.movies.len().try_into().unwrap_or(0)),
 						}
 						.insert(txn)
@@ -65,7 +75,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				Err(TransactionError::Connection(err)) => Err(err)?,
 				Err(TransactionError::Transaction(err)) => Err(err)?,
 			};
-			println!("Created Collection: {}", flix_id.into_raw());
+			println!("Created Collection: {} [{}]", title, flix_id.into_raw());
 
 			Ok(())
 		}
@@ -83,6 +93,13 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				.await
 				.with_context(|| format!("movies().get_details({})", id.into_raw()))?;
 
+			let title = movie.title.clone();
+			let year = movie.release_date.year();
+
+			let sort_title = text::make_sortable_title(&title);
+			let fs_slug = text::make_fs_slug_year(&title, year);
+			let web_slug = text::make_web_slug_year(&title, year);
+
 			let result: Result<MovieId, TransactionError<DbErr>> = db
 				.transaction(|txn| {
 					Box::pin(async move {
@@ -92,6 +109,9 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 							tagline: Set(movie.tagline),
 							overview: Set(movie.overview),
 							date: Set(movie.release_date),
+							sort_title: Set(sort_title),
+							fs_slug: Set(fs_slug),
+							web_slug: Set(web_slug),
 						}
 						.insert(txn)
 						.await?;
@@ -99,7 +119,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 						entity::tmdb::movies::ActiveModel {
 							tmdb_id: Set(id),
 							flix_id: Set(flix.id),
-							last_update: Set(Utc::now().naive_utc().date()),
+							last_update: Set(Utc::now()),
 							runtime: Set(movie.runtime.into()),
 							collection_id: Set(movie.collection.map(|c| c.id)),
 						}
@@ -116,7 +136,12 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				Err(TransactionError::Connection(err)) => Err(err)?,
 				Err(TransactionError::Transaction(err)) => Err(err)?,
 			};
-			println!("Created Movie: {}", flix_id.into_raw());
+			println!(
+				"Created Movie: {} ({}) [{}]",
+				title,
+				year,
+				flix_id.into_raw(),
+			);
 
 			Ok(())
 		}
@@ -136,14 +161,24 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 			let mut seasons = Vec::new();
 			let mut episodes = HashMap::new();
 
+			let title = show.title.clone();
+			let year = show.first_air_date.year();
+
 			for season in 1..=show.number_of_seasons {
-				let season = client
+				let season = SeasonNumber::new(season);
+				let season = match client
 					.seasons()
 					.get_details(id, season, None)
 					.await
 					.with_context(|| {
 						format!("seasons().get_details({}, {})", id.into_raw(), season)
-					})?;
+					}) {
+					Ok(season) => season,
+					Err(err) => {
+						eprintln!("{err:?}");
+						continue;
+					}
+				};
 				if season.air_date > Utc::now().naive_utc().date() {
 					eprintln!(
 						"skipping season ({}, {})",
@@ -153,7 +188,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 					break;
 				}
 
-				let Ok(number_of_episodes) = EpisodeNumber::try_from(season.episodes.len()) else {
+				let Ok(number_of_episodes) = u32::try_from(season.episodes.len()) else {
 					bail!(
 						"could not convert {} to an EpisodeNumber",
 						season.episodes.len()
@@ -162,6 +197,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 
 				let mut season_episodes = Vec::new();
 				for episode in 1..=number_of_episodes {
+					let episode = EpisodeNumber::new(episode);
 					let Ok(episode) = client
 						.episodes()
 						.get_details(id, season.season_number, episode, None)
@@ -182,6 +218,10 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				seasons.push(season);
 			}
 
+			let sort_title = text::make_sortable_title(&show.title);
+			let fs_slug = text::make_fs_slug_year(&show.title, show.first_air_date.year());
+			let web_slug = text::make_web_slug_year(&show.title, show.first_air_date.year());
+
 			let result: Result<ShowId, TransactionError<DbErr>> = db
 				.transaction(|txn| {
 					Box::pin(async move {
@@ -191,6 +231,9 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 							tagline: Set(show.tagline),
 							overview: Set(show.overview),
 							date: Set(show.first_air_date),
+							sort_title: Set(sort_title),
+							fs_slug: Set(fs_slug),
+							web_slug: Set(web_slug),
 						}
 						.insert(txn)
 						.await?;
@@ -198,7 +241,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 						entity::tmdb::shows::ActiveModel {
 							tmdb_id: Set(id),
 							flix_id: Set(flix.id),
-							last_update: Set(Utc::now().naive_utc().date()),
+							last_update: Set(Utc::now()),
 							number_of_seasons: Set(show.number_of_seasons),
 						}
 						.insert(txn)
@@ -220,7 +263,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 								tmdb_season: Set(season.season_number),
 								flix_show: Set(flix.id),
 								flix_season: Set(season.season_number),
-								last_update: Set(Utc::now().naive_utc().date()),
+								last_update: Set(Utc::now()),
 							}
 							.insert(txn)
 							.await?;
@@ -246,7 +289,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 									flix_show: Set(flix.id),
 									flix_season: Set(season),
 									flix_episode: Set(episode.episode_number),
-									last_update: Set(Utc::now().naive_utc().date()),
+									last_update: Set(Utc::now()),
 									runtime: Set(episode.runtime.into()),
 								}
 								.insert(txn)
@@ -264,7 +307,12 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				Err(TransactionError::Connection(err)) => Err(err)?,
 				Err(TransactionError::Transaction(err)) => Err(err)?,
 			};
-			println!("Created Show: {}", flix_id.into_raw());
+			println!(
+				"Created Show: {} ({}) [{}]",
+				title,
+				year,
+				flix_id.into_raw()
+			);
 
 			Ok(())
 		}
@@ -296,7 +344,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 				})?;
 			let mut episodes = Vec::new();
 
-			let Ok(number_of_episodes) = EpisodeNumber::try_from(season.episodes.len()) else {
+			let Ok(number_of_episodes) = u32::try_from(season.episodes.len()) else {
 				bail!(
 					"could not convert {} to an EpisodeNumber",
 					season.episodes.len()
@@ -304,6 +352,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 			};
 
 			for episode in 1..=number_of_episodes {
+				let episode = EpisodeNumber::new(episode);
 				let Ok(episode) = client
 					.episodes()
 					.get_details(id, season.season_number, episode, None)
@@ -338,7 +387,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 							tmdb_season: Set(season_number),
 							flix_show: Set(show.flix_id),
 							flix_season: Set(season_number),
-							last_update: Set(Utc::now().naive_utc().date()),
+							last_update: Set(Utc::now()),
 						}
 						.insert(txn)
 						.await?;
@@ -362,7 +411,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 								flix_show: Set(show.flix_id),
 								flix_season: Set(season_number),
 								flix_episode: Set(episode.episode_number),
-								last_update: Set(Utc::now().naive_utc().date()),
+								last_update: Set(Utc::now()),
 								runtime: Set(episode.runtime.into()),
 							}
 							.insert(txn)
@@ -453,7 +502,7 @@ pub async fn add(client: Client, db: &DatabaseConnection, command: Command) -> R
 								flix_show: Set(flix_id),
 								flix_season: Set(season),
 								flix_episode: Set(episode_number),
-								last_update: Set(Utc::now().naive_utc().date()),
+								last_update: Set(Utc::now()),
 								runtime: Set(episode.runtime.into()),
 							}
 							.insert(txn)
@@ -498,10 +547,3 @@ pub async fn update(client: Client, database: &DatabaseConnection, command: Comm
 	_ = command;
 	unimplemented!("updates")
 }
-
-pub async fn delete(client: Client, database: &DatabaseConnection, command: Command) -> Result<()> {
-	_ = client;
-	_ = database;
-	_ = command;
-	unimplemented!("deletions")
-}

crates/db/Cargo.toml

@@ -1,45 +1,39 @@
 [package]
 name = "flix-db"
-version = "0.0.14"
+version = "0.0.16"
-
+edition.workspace = true
-categories = []
+rust-version.workspace = true
 description = "Types for storing persistent data about media"
 repository = "https://github.com/QuantumShade/flix"
-
-authors.workspace = true
-edition.workspace = true
 license-file.workspace = true
-rust-version.workspace = true
+categories = []
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints]
-workspace = true
-
-[features]
-default = []
-tmdb = ["dep:flix-tmdb"]
-
 [dependencies]
-flix-model = { workspace = true }
-
-flix-tmdb = { workspace = true, optional = true, features = ["sea-orm"] }
-
-seamantic = { workspace = true, features = ["sqlite"] }
-
 chrono = { workspace = true }
+flix-model = { workspace = true }
+flix-tmdb = { workspace = true, features = ["sea-orm"], optional = true }
 sea-orm = { workspace = true, features = [
 	"entity-registry",
 	"schema-sync",
 	"with-chrono",
 ] }
 sea-orm-migration = { workspace = true }
+seamantic = { workspace = true, features = ["sqlite"] }
 
 [dev-dependencies]
 sea-orm-migration = { workspace = true, features = ["runtime-tokio-rustls"] }
 tokio = { version = "^1", default-features = false, features = [
-	"rt",
 	"macros",
+	"rt",
 ] }
+
+[features]
+default = []
+tmdb = ["dep:flix-tmdb"]
+
+[lints]
+workspace = true

crates/db/src/entity/content.rs

@@ -6,7 +6,7 @@ pub mod libraries {
 
 	use seamantic::model::path::PathBytes;
 
-	use chrono::NaiveDateTime;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	/// The database representation of a library media folder
@@ -15,27 +15,27 @@ pub mod libraries {
 	#[sea_orm(table_name = "flix_libraries")]
 	pub struct Model {
 		/// The library's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: LibraryId,
 		/// The library's directory
 		pub directory: PathBytes,
 		/// The library's last scan data
-		pub last_scan: Option<NaiveDateTime>,
+		pub last_scan: Option<DateTime<Utc>>,
 
 		/// Collections that are part of this library
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub collections: HasMany<super::collections::Entity>,
 		/// Movies that are part of this library
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub movies: HasMany<super::movies::Entity>,
 		/// Shows that are part of this library
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub shows: HasMany<super::shows::Entity>,
 		/// Seasons that are part of this library
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub seasons: HasMany<super::seasons::Entity>,
 		/// Episodes that are part of this library
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub episodes: HasMany<super::episodes::Entity>,
 	}
 
@@ -58,14 +58,11 @@ pub mod collections {
 	#[sea_orm(table_name = "flix_collections")]
 	pub struct Model {
 		/// The collection's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: CollectionId,
 		/// The collection's parent
 		#[sea_orm(indexed)]
 		pub parent_id: Option<CollectionId>,
-		/// The collection's slug
-		#[sea_orm(unique)]
-		pub slug: String,
 		/// The collection's library ID
 		pub library_id: LibraryId,
 		/// The collection's directory
@@ -74,14 +71,35 @@ pub mod collections {
 		pub relative_poster_path: Option<String>,
 
 		/// This collection's parent
-		#[sea_orm(self_ref, relation_enum = "Parent", from = "parent_id", to = "id")]
+		#[sea_orm(
+			self_ref,
+			relation_enum = "Parent",
+			from = "parent_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub parent: HasOne<Entity>,
 		/// The library this collection belongs to
-		#[sea_orm(belongs_to, from = "library_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "library_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub library: HasOne<super::libraries::Entity>,
 		/// The info for this collection
-		#[sea_orm(belongs_to, relation_enum = "Info", from = "id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			relation_enum = "Info",
+			from = "id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::collections::Entity>,
+
 		/// The watched info for this collection
 		#[sea_orm(has_many, relation_enum = "Watched", from = "id", to = "id")]
 		pub watched: HasMany<entity::watched::collections::Entity>,
@@ -106,14 +124,11 @@ pub mod movies {
 	#[sea_orm(table_name = "flix_movies")]
 	pub struct Model {
 		/// The movie's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: MovieId,
 		/// The movie's parent
 		#[sea_orm(indexed)]
 		pub parent_id: Option<CollectionId>,
-		/// The movie's slug
-		#[sea_orm(unique)]
-		pub slug: String,
 		/// The movie's library
 		pub library_id: LibraryId,
 		/// The movie's directory
@@ -124,14 +139,34 @@ pub mod movies {
 		pub relative_poster_path: Option<String>,
 
 		/// This movie's parent
-		#[sea_orm(belongs_to, from = "parent_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "parent_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub parent: HasOne<super::collections::Entity>,
 		/// The library this movie belongs to
-		#[sea_orm(belongs_to, from = "library_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "library_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub library: HasOne<super::libraries::Entity>,
 		/// The info for this movie
-		#[sea_orm(belongs_to, relation_enum = "Info", from = "id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			relation_enum = "Info",
+			from = "id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::movies::Entity>,
+
 		/// The watched info for this movie
 		#[sea_orm(has_many, relation_enum = "Watched", from = "id", to = "id")]
 		pub watched: HasMany<entity::watched::movies::Entity>,
@@ -156,14 +191,11 @@ pub mod shows {
 	#[sea_orm(table_name = "flix_shows")]
 	pub struct Model {
 		/// The show's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: ShowId,
 		/// The show's parent
 		#[sea_orm(indexed)]
 		pub parent_id: Option<CollectionId>,
-		/// The show's slug
-		#[sea_orm(unique)]
-		pub slug: String,
 		/// The show's library
 		pub library_id: LibraryId,
 		/// The show's directory
@@ -172,14 +204,40 @@ pub mod shows {
 		pub relative_poster_path: Option<String>,
 
 		/// This show's parent
-		#[sea_orm(belongs_to, from = "parent_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "parent_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub parent: HasOne<super::collections::Entity>,
 		/// The library this show belongs to
-		#[sea_orm(belongs_to, from = "library_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "library_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub library: HasOne<super::libraries::Entity>,
 		/// The info for this show
-		#[sea_orm(belongs_to, relation_enum = "Info", from = "id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			relation_enum = "Info",
+			from = "id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::shows::Entity>,
+
+		/// Seasons that are part of this show
+		#[sea_orm(has_many)]
+		pub seasons: HasMany<super::seasons::Entity>,
+		/// Episodes that are part of this show
+		#[sea_orm(has_many)]
+		pub episodes: HasMany<super::episodes::Entity>,
 		/// The watched info for this show
 		#[sea_orm(has_many, relation_enum = "Watched", from = "id", to = "id")]
 		pub watched: HasMany<entity::watched::shows::Entity>,
@@ -210,9 +268,6 @@ pub mod seasons {
 		/// The season's number
 		#[sea_orm(primary_key, auto_increment = false)]
 		pub season_number: SeasonNumber,
-		/// The season's slug
-		#[sea_orm(unique)]
-		pub slug: String,
 		/// The season's library
 		pub library_id: LibraryId,
 		/// The season's directory
@@ -220,17 +275,38 @@ pub mod seasons {
 		/// The season's poster path
 		pub relative_poster_path: Option<String>,
 
+		/// This season's show
+		#[sea_orm(
+			belongs_to,
+			from = "show_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
+		pub show: HasOne<super::shows::Entity>,
 		/// The library this season belongs to
-		#[sea_orm(belongs_to, from = "library_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "library_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub library: HasOne<super::libraries::Entity>,
 		/// The info for this season
 		#[sea_orm(
 			belongs_to,
 			relation_enum = "Info",
 			from = "(show_id, season_number)",
-			to = "(show_id, season_number)"
+			to = "(show_id, season_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub info: HasOne<entity::info::seasons::Entity>,
+
+		/// Episodes that are part of this show
+		#[sea_orm(has_many)]
+		pub episodes: HasMany<super::episodes::Entity>,
 		/// The watched info for this season
 		#[sea_orm(
 			has_many,
@@ -271,9 +347,6 @@ pub mod episodes {
 		pub episode_number: EpisodeNumber,
 		/// The number of additional contained episodes
 		pub count: u8,
-		/// The episode's slug
-		#[sea_orm(unique)]
-		pub slug: String,
 		/// The episode's library
 		pub library_id: LibraryId,
 		/// The episode's directory
@@ -283,17 +356,44 @@ pub mod episodes {
 		/// The episode's poster path
 		pub relative_poster_path: Option<String>,
 
+		/// This episode's show
+		#[sea_orm(
+			belongs_to,
+			from = "show_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
+		pub show: HasOne<super::shows::Entity>,
+		/// This episode's season
+		#[sea_orm(
+			belongs_to,
+			from = "(show_id, season_number)",
+			to = "(show_id, season_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
+		pub season: HasOne<super::seasons::Entity>,
 		/// The library this episode belongs to
-		#[sea_orm(belongs_to, from = "library_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "library_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub library: HasOne<super::libraries::Entity>,
 		/// The info for this episode
 		#[sea_orm(
 			belongs_to,
 			relation_enum = "Info",
 			from = "(show_id, season_number, episode_number)",
-			to = "(show_id, season_number, episode_number)"
+			to = "(show_id, season_number, episode_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub info: HasOne<entity::info::episodes::Entity>,
+
 		/// The watched info for this episode
 		#[sea_orm(
 			has_many,
@@ -311,7 +411,7 @@ pub mod episodes {
 #[cfg(test)]
 pub mod test {
 	macro_rules! make_content_library {
-		($db:expr, $id:literal) => {
+		($db:expr, $id:expr) => {
 			$crate::entity::content::libraries::ActiveModel {
 				id: Set(::flix_model::id::LibraryId::from_raw($id)),
 				directory: Set(::std::path::PathBuf::new().into()),
@@ -325,12 +425,11 @@ pub mod test {
 	pub(crate) use make_content_library;
 
 	macro_rules! make_content_collection {
-		($db:expr, $lid:literal, $id:literal, $pid:expr) => {
+		($db:expr, $lid:expr, $id:expr, $pid:expr) => {
 			$crate::entity::info::test::make_info_collection!($db, $id);
 			$crate::entity::content::collections::ActiveModel {
 				id: Set(::flix_model::id::CollectionId::from_raw($id)),
 				parent_id: Set($pid.map(::flix_model::id::CollectionId::from_raw)),
-				slug: Set(concat!("C ", $id).to_string()),
 				library_id: Set(::flix_model::id::LibraryId::from_raw($lid)),
 				directory: Set(::std::path::PathBuf::new().into()),
 				relative_poster_path: Set(::core::option::Option::None),
@@ -343,12 +442,11 @@ pub mod test {
 	pub(crate) use make_content_collection;
 
 	macro_rules! make_content_movie {
-		($db:expr, $lid:literal, $id:literal, $pid:expr) => {
+		($db:expr, $lid:expr, $id:expr, $pid:expr) => {
 			$crate::entity::info::test::make_info_movie!($db, $id);
 			$crate::entity::content::movies::ActiveModel {
 				id: Set(::flix_model::id::MovieId::from_raw($id)),
 				parent_id: Set($pid.map(::flix_model::id::CollectionId::from_raw)),
-				slug: Set(concat!("< ", $id).to_string()),
 				library_id: Set(::flix_model::id::LibraryId::from_raw($lid)),
 				directory: Set(::std::path::PathBuf::new().into()),
 				relative_media_path: Set(::std::string::String::new()),
@@ -362,12 +460,11 @@ pub mod test {
 	pub(crate) use make_content_movie;
 
 	macro_rules! make_content_show {
-		($db:expr, $lid:literal, $id:literal, $pid:expr) => {
+		($db:expr, $lid:expr, $id:expr, $pid:expr) => {
 			$crate::entity::info::test::make_info_show!($db, $id);
 			$crate::entity::content::shows::ActiveModel {
 				id: Set(::flix_model::id::ShowId::from_raw($id)),
 				parent_id: Set($pid.map(::flix_model::id::CollectionId::from_raw)),
-				slug: Set(concat!("S ", $id).to_string()),
 				library_id: Set(::flix_model::id::LibraryId::from_raw($lid)),
 				directory: Set(::std::path::PathBuf::new().into()),
 				relative_poster_path: Set(::core::option::Option::None),
@@ -380,12 +477,11 @@ pub mod test {
 	pub(crate) use make_content_show;
 
 	macro_rules! make_content_season {
-		($db:expr, $lid:literal, $show:literal, $season:literal) => {
+		($db:expr, $lid:expr, $show:expr, $season:expr) => {
 			$crate::entity::info::test::make_info_season!($db, $show, $season);
 			$crate::entity::content::seasons::ActiveModel {
 				show_id: Set(::flix_model::id::ShowId::from_raw($show)),
-				season_number: Set($season),
+				season_number: Set(::flix_model::numbers::SeasonNumber::new($season)),
-				slug: Set(concat!("SS ", $show, $season).to_string()),
 				library_id: Set(::flix_model::id::LibraryId::from_raw($lid)),
 				directory: Set(::std::path::PathBuf::new().into()),
 				relative_poster_path: Set(::core::option::Option::None),
@@ -398,20 +494,19 @@ pub mod test {
 	pub(crate) use make_content_season;
 
 	macro_rules! make_content_episode {
-		($db:expr, $lid:literal, $show:literal, $season:literal, $episode:literal) => {
+		($db:expr, $lid:expr, $show:expr, $season:expr, $episode:expr) => {
 			make_content_episode!(@make, $db, $lid, $show, $season, $episode, 0);
 		};
 		($db:expr, $lid:literal, $show:literal, $season:literal, $episode:literal, >1) => {
 			make_content_episode!(@make, $db, $lid, $show, $season, $episode, 1);
 		};
-		(@make, $db:expr, $lid:literal, $show:literal, $season:literal, $episode:literal, $count:literal) => {
+		(@make, $db:expr, $lid:expr, $show:expr, $season:expr, $episode:expr, $count:literal) => {
 			$crate::entity::info::test::make_info_episode!($db, $show, $season, $episode);
 			$crate::entity::content::episodes::ActiveModel {
 				show_id: Set(::flix_model::id::ShowId::from_raw($show)),
-				season_number: Set($season),
+				season_number: Set(::flix_model::numbers::SeasonNumber::new($season)),
-				episode_number: Set($episode),
+				episode_number: Set(::flix_model::numbers::EpisodeNumber::new($episode)),
 				count: Set($count),
-				slug: Set(concat!("SSE ", $show, $season, $episode).to_string()),
 				library_id: Set(::flix_model::id::LibraryId::from_raw($lid)),
 				directory: Set(::std::path::PathBuf::new().into()),
 				relative_media_path: Set(::std::string::String::new()),
@@ -431,7 +526,7 @@ mod tests {
 
 	use flix_model::id::{CollectionId, LibraryId, MovieId, ShowId};
 
-	use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
+	use chrono::NaiveDate;
 	use sea_orm::ActiveValue::{NotSet, Set};
 	use sea_orm::entity::prelude::*;
 	use sea_orm::sqlx::error::ErrorKind;
@@ -471,7 +566,7 @@ mod tests {
 
 				assert_eq!(model.id, LibraryId::from_raw($id));
 				assert_eq!(model.directory, Path::new(concat!("L Directory ", $id)).to_owned().into());
-				assert_eq!(model.last_scan, noneable!(last_scan, NaiveDateTime::new(NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt"), NaiveTime::from_hms_opt(1, 1, 1).expect("from_yo_opt")) $(, $($skip),+)?));
+				assert_eq!(model.last_scan, noneable!(last_scan, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?));
 			};
 			($db:expr, $id:literal, $error:ident $(; $($skip:ident),+)?) => {
 				let model = assert_library!(@insert, $db, $id $(; $($skip),+)?)
@@ -483,7 +578,7 @@ mod tests {
 				super::libraries::ActiveModel {
 					id: notsettable!(id, LibraryId::from_raw($id) $(, $($skip),+)?),
 					directory: notsettable!(directory, Path::new(concat!("L Directory ", $id)).to_owned().into() $(, $($skip),+)?),
-					last_scan: notsettable!(last_scan, Some(NaiveDateTime::new(NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt"), NaiveTime::from_hms_opt(1, 1, 1).expect("from_yo_opt"))) $(, $($skip),+)?),
+					last_scan: notsettable!(last_scan, Some(NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc()) $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}
@@ -507,7 +602,6 @@ mod tests {
 
 				assert_eq!(model.id, CollectionId::from_raw($id));
 				assert_eq!(model.parent_id, $pid.map(CollectionId::from_raw));
-				assert_eq!(model.slug, concat!("C Slug ", $id).to_string());
 				assert_eq!(model.library_id, LibraryId::from_raw($lid));
 				assert_eq!(model.directory, Path::new(concat!("C Directory ", $id)).to_owned().into());
 				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, concat!("C Poster ", $id).to_owned() $(, $($skip),+)?));
@@ -522,7 +616,6 @@ mod tests {
 				super::collections::ActiveModel {
 					id: notsettable!(id, CollectionId::from_raw($id) $(, $($skip),+)?),
 					parent_id: notsettable!(parent_id, $pid.map(CollectionId::from_raw) $(, $($skip),+)?),
-					slug: notsettable!(slug, concat!("C Slug ", $id).to_string() $(, $($skip),+)?),
 					library_id: notsettable!(library_id, LibraryId::from_raw($lid) $(, $($skip),+)?),
 					directory: notsettable!(directory, Path::new(concat!("C Directory ", $id)).to_owned().into() $(, $($skip),+)?),
 					relative_poster_path: notsettable!(relative_poster_path, Some(concat!("C Poster ", $id).to_owned()) $(, $($skip),+)?),
@@ -548,10 +641,9 @@ mod tests {
 		make_info_collection!(&db, 8);
 		assert_collection!(&db, 3, None, 1, Success; id);
 		assert_collection!(&db, 4, None, 1, Success; parent_id);
-		assert_collection!(&db, 5, None, 1, NotNullViolation; slug);
+		assert_collection!(&db, 5, None, 1, NotNullViolation; library_id);
-		assert_collection!(&db, 6, None, 1, NotNullViolation; library_id);
+		assert_collection!(&db, 6, None, 1, NotNullViolation; directory);
-		assert_collection!(&db, 7, None, 1, NotNullViolation; directory);
+		assert_collection!(&db, 7, None, 1, Success; relative_poster_path);
-		assert_collection!(&db, 8, None, 1, Success; relative_poster_path);
 	}
 
 	#[tokio::test]
@@ -565,7 +657,6 @@ mod tests {
 
 				assert_eq!(model.id, MovieId::from_raw($id));
 				assert_eq!(model.parent_id, $pid.map(CollectionId::from_raw));
-				assert_eq!(model.slug, concat!("M Slug ", $id).to_string());
 				assert_eq!(model.library_id, LibraryId::from_raw($lid));
 				assert_eq!(model.directory, Path::new(concat!("M Directory ", $id)).to_owned().into());
 				assert_eq!(model.relative_media_path, concat!("M Media ", $id));
@@ -581,7 +672,6 @@ mod tests {
 				super::movies::ActiveModel {
 					id: notsettable!(id, MovieId::from_raw($id) $(, $($skip),+)?),
 					parent_id: notsettable!(parent_id, $pid.map(CollectionId::from_raw) $(, $($skip),+)?),
-					slug: notsettable!(slug, concat!("M Slug ", $id).to_string() $(, $($skip),+)?),
 					library_id: notsettable!(library_id, LibraryId::from_raw($lid) $(, $($skip),+)?),
 					directory: notsettable!(directory, Path::new(concat!("M Directory ", $id)).to_owned().into() $(, $($skip),+)?),
 					relative_media_path: notsettable!(relative_media_path, concat!("M Media ", $id).to_owned() $(, $($skip),+)?),
@@ -612,11 +702,10 @@ mod tests {
 		make_info_movie!(&db, 9);
 		assert_movie!(&db, 3, None, 1, Success; id);
 		assert_movie!(&db, 4, None, 1, Success; parent_id);
-		assert_movie!(&db, 5, None, 1, NotNullViolation; slug);
+		assert_movie!(&db, 5, None, 1, NotNullViolation; library_id);
-		assert_movie!(&db, 6, None, 1, NotNullViolation; library_id);
+		assert_movie!(&db, 6, None, 1, NotNullViolation; directory);
-		assert_movie!(&db, 7, None, 1, NotNullViolation; directory);
+		assert_movie!(&db, 7, None, 1, NotNullViolation; relative_media_path);
-		assert_movie!(&db, 8, None, 1, NotNullViolation; relative_media_path);
+		assert_movie!(&db, 8, None, 1, Success; relative_poster_path);
-		assert_movie!(&db, 9, None, 1, Success; relative_poster_path);
 	}
 
 	#[tokio::test]
@@ -630,7 +719,6 @@ mod tests {
 
 				assert_eq!(model.id, ShowId::from_raw($id));
 				assert_eq!(model.parent_id, $pid.map(CollectionId::from_raw));
-				assert_eq!(model.slug, concat!("S Slug ", $id).to_string());
 				assert_eq!(model.library_id, LibraryId::from_raw($lid));
 				assert_eq!(model.directory, Path::new(concat!("S Directory ", $id)).to_owned().into());
 				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, concat!("S Poster ", $id).to_owned() $(, $($skip),+)?));
@@ -645,7 +733,6 @@ mod tests {
 				super::shows::ActiveModel {
 					id: notsettable!(id, ShowId::from_raw($id) $(, $($skip),+)?),
 					parent_id: notsettable!(parent_id, $pid.map(CollectionId::from_raw) $(, $($skip),+)?),
-					slug: notsettable!(slug, concat!("S Slug ", $id).to_string() $(, $($skip),+)?),
 					library_id: notsettable!(library_id, LibraryId::from_raw($lid) $(, $($skip),+)?),
 					directory: notsettable!(directory, Path::new(concat!("S Directory ", $id)).to_owned().into() $(, $($skip),+)?),
 					relative_poster_path: notsettable!(relative_poster_path, Some(concat!("S Poster ", $id).to_owned()) $(, $($skip),+)?),
@@ -674,10 +761,9 @@ mod tests {
 		make_info_show!(&db, 8);
 		assert_show!(&db, 3, None, 1, Success; id);
 		assert_show!(&db, 4, None, 1, Success; parent_id);
-		assert_show!(&db, 5, None, 1, NotNullViolation; slug);
+		assert_show!(&db, 5, None, 1, NotNullViolation; library_id);
-		assert_show!(&db, 6, None, 1, NotNullViolation; library_id);
+		assert_show!(&db, 6, None, 1, NotNullViolation; directory);
-		assert_show!(&db, 7, None, 1, NotNullViolation; directory);
+		assert_show!(&db, 7, None, 1, Success; relative_poster_path);
-		assert_show!(&db, 8, None, 1, Success; relative_poster_path);
 	}
 
 	#[tokio::test]
@@ -690,8 +776,7 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.show_id, ShowId::from_raw($id));
-				assert_eq!(model.season_number, $season);
+				assert_eq!(model.season_number, ::flix_model::numbers::SeasonNumber::new($season));
-				assert_eq!(model.slug, concat!("SS Slug ", $id, ",", $season).to_string());
 				assert_eq!(model.library_id, LibraryId::from_raw($lid));
 				assert_eq!(model.directory, Path::new(concat!("SS Directory ", $id, ",", $season)).to_owned().into());
 				assert_eq!(model.relative_poster_path, noneable!(relative_poster_path, concat!("SS Poster ", $id, ",", $season).to_owned() $(, $($skip),+)?));
@@ -705,8 +790,7 @@ mod tests {
 			(@insert, $db:expr, $id:literal, $season:literal, $lid:literal $(; $($skip:ident),+)?) => {
 				super::seasons::ActiveModel {
 					show_id: notsettable!(show_id, ShowId::from_raw($id) $(, $($skip),+)?),
-					season_number: notsettable!(season_number, $season $(, $($skip),+)?),
+					season_number: notsettable!(season_number, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
-					slug: notsettable!(slug, concat!("SS Slug ", $id, ",", $season).to_string() $(, $($skip),+)?),
 					library_id: notsettable!(library_id, LibraryId::from_raw($lid) $(, $($skip),+)?),
 					directory: notsettable!(directory, Path::new(concat!("SS Directory ", $id, ",", $season)).to_owned().into() $(, $($skip),+)?),
 					relative_poster_path: notsettable!(relative_poster_path, Some(concat!("SS Poster ", $id, ",", $season).to_owned()) $(, $($skip),+)?),
@@ -715,7 +799,7 @@ mod tests {
 		}
 
 		make_content_library!(&db, 1);
-		make_info_show!(&db, 1);
+		make_content_show!(&db, 1, 1, None);
 		assert_season!(&db, 1, 1, 1, ForeignKeyViolation);
 		make_info_season!(&db, 1, 1);
 		assert_season!(&db, 1, 1, 1, Success);
@@ -729,10 +813,9 @@ mod tests {
 		make_info_season!(&db, 1, 8);
 		assert_season!(&db, 1, 3, 1, NotNullViolation; show_id);
 		assert_season!(&db, 1, 4, 1, NotNullViolation; season_number);
-		assert_season!(&db, 1, 5, 1, NotNullViolation; slug);
+		assert_season!(&db, 1, 5, 1, NotNullViolation; library_id);
-		assert_season!(&db, 1, 6, 1, NotNullViolation; library_id);
+		assert_season!(&db, 1, 6, 1, NotNullViolation; directory);
-		assert_season!(&db, 1, 7, 1, NotNullViolation; directory);
+		assert_season!(&db, 1, 7, 1, Success; relative_poster_path);
-		assert_season!(&db, 1, 8, 1, Success; relative_poster_path);
 	}
 
 	#[tokio::test]
@@ -745,9 +828,8 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.show_id, ShowId::from_raw($id));
-				assert_eq!(model.season_number, $season);
+				assert_eq!(model.season_number, ::flix_model::numbers::SeasonNumber::new($season));
-				assert_eq!(model.episode_number, $episode);
+				assert_eq!(model.episode_number, ::flix_model::numbers::EpisodeNumber::new($episode));
-				assert_eq!(model.slug, concat!("SS Slug ", $id, ",", $season, $episode).to_string());
 				assert_eq!(model.library_id, LibraryId::from_raw($lid));
 				assert_eq!(model.directory, Path::new(concat!("SS Directory ", $id, ",", $season, $episode)).to_owned().into());
 				assert_eq!(model.relative_media_path, concat!("SS Media ", $id, ",", $season, $episode));
@@ -762,10 +844,9 @@ mod tests {
 			(@insert, $db:expr, $id:literal, $season:literal, $episode:literal, $lid:literal $(; $($skip:ident),+)?) => {
 				super::episodes::ActiveModel {
 					show_id: notsettable!(show_id, ShowId::from_raw($id) $(, $($skip),+)?),
-					season_number: notsettable!(season_number, $season $(, $($skip),+)?),
+					season_number: notsettable!(season_number, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
-					episode_number: notsettable!(episode_number, $episode $(, $($skip),+)?),
+					episode_number: notsettable!(episode_number, ::flix_model::numbers::EpisodeNumber::new($episode) $(, $($skip),+)?),
 					count: notsettable!(count, 0 $(, $($skip),+)?),
-					slug: notsettable!(slug, concat!("SS Slug ", $id, ",", $season, $episode).to_string() $(, $($skip),+)?),
 					library_id: notsettable!(library_id, LibraryId::from_raw($lid) $(, $($skip),+)?),
 					directory: notsettable!(directory, Path::new(concat!("SS Directory ", $id, ",", $season, $episode)).to_owned().into() $(, $($skip),+)?),
 					relative_media_path: notsettable!(relative_media_path, concat!("SS Media ", $id, ",", $season, $episode).to_owned() $(, $($skip),+)?),
@@ -775,8 +856,8 @@ mod tests {
 		}
 
 		make_content_library!(&db, 1);
-		make_info_show!(&db, 1);
+		make_content_show!(&db, 1, 1, None);
-		make_info_season!(&db, 1, 1);
+		make_content_season!(&db, 1, 1, 1);
 		assert_episode!(&db, 1, 1, 1, 1, ForeignKeyViolation);
 		make_info_episode!(&db, 1, 1, 1);
 		assert_episode!(&db, 1, 1, 1, 1, Success);
@@ -793,10 +874,9 @@ mod tests {
 		assert_episode!(&db, 1, 1, 3, 1, NotNullViolation; show_id);
 		assert_episode!(&db, 1, 1, 4, 1, NotNullViolation; season_number);
 		assert_episode!(&db, 1, 1, 5, 1, NotNullViolation; episode_number);
-		assert_episode!(&db, 1, 1, 6, 1, NotNullViolation; slug);
+		assert_episode!(&db, 1, 1, 6, 1, NotNullViolation; library_id);
-		assert_episode!(&db, 1, 1, 7, 1, NotNullViolation; library_id);
+		assert_episode!(&db, 1, 1, 7, 1, NotNullViolation; directory);
-		assert_episode!(&db, 1, 1, 8, 1, NotNullViolation; directory);
+		assert_episode!(&db, 1, 1, 8, 1, NotNullViolation; relative_media_path);
-		assert_episode!(&db, 1, 1, 9, 1, NotNullViolation; relative_media_path);
+		assert_episode!(&db, 1, 1, 9, 1, Success; relative_poster_path);
-		assert_episode!(&db, 1, 1, 10, 1, Success; relative_poster_path);
 	}
 }

crates/db/src/entity/info.rs

@@ -13,13 +13,22 @@ pub mod collections {
 	#[sea_orm(table_name = "flix_info_collections")]
 	pub struct Model {
 		/// The collection's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: CollectionId,
 		/// The collection's title
-		#[sea_orm(indexed)]
 		pub title: String,
 		/// The collection's overview
 		pub overview: String,
+
+		/// The sortable title
+		#[sea_orm(indexed)]
+		pub sort_title: String,
+		/// The filesystem-safe slug
+		#[sea_orm(indexed, unique)]
+		pub fs_slug: String,
+		/// The url-safe slug
+		#[sea_orm(indexed, unique)]
+		pub web_slug: String,
 	}
 
 	impl ActiveModelBehavior for ActiveModel {}
@@ -38,10 +47,9 @@ pub mod movies {
 	#[sea_orm(table_name = "flix_info_movies")]
 	pub struct Model {
 		/// The movie's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: MovieId,
 		/// The movie's title
-		#[sea_orm(indexed)]
 		pub title: String,
 		/// The movie's tagline
 		pub tagline: String,
@@ -50,6 +58,16 @@ pub mod movies {
 		/// The movie's release date
 		#[sea_orm(indexed)]
 		pub date: NaiveDate,
+
+		/// The sortable title
+		#[sea_orm(indexed)]
+		pub sort_title: String,
+		/// The filesystem-safe slug
+		#[sea_orm(indexed, unique)]
+		pub fs_slug: String,
+		/// The url-safe slug
+		#[sea_orm(indexed, unique)]
+		pub web_slug: String,
 	}
 
 	impl ActiveModelBehavior for ActiveModel {}
@@ -68,10 +86,9 @@ pub mod shows {
 	#[sea_orm(table_name = "flix_info_shows")]
 	pub struct Model {
 		/// The show's ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub id: ShowId,
 		/// The show's title
-		#[sea_orm(indexed)]
 		pub title: String,
 		/// The show's tagline
 		pub tagline: String,
@@ -81,11 +98,21 @@ pub mod shows {
 		#[sea_orm(indexed)]
 		pub date: NaiveDate,
 
+		/// The sortable title
+		#[sea_orm(indexed)]
+		pub sort_title: String,
+		/// The filesystem-safe slug
+		#[sea_orm(indexed, unique)]
+		pub fs_slug: String,
+		/// The url-safe slug
+		#[sea_orm(indexed, unique)]
+		pub web_slug: String,
+
 		/// Seasons that are part of this show
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub seasons: HasMany<super::seasons::Entity>,
 		/// Episodes that are part of this show
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub episodes: HasMany<super::episodes::Entity>,
 	}
 
@@ -120,10 +147,16 @@ pub mod seasons {
 		pub date: NaiveDate,
 
 		/// The show this season belongs to
-		#[sea_orm(belongs_to, from = "show_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "show_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub show: HasOne<super::shows::Entity>,
 		/// Episodes that are part of this season
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub episodes: HasMany<super::episodes::Entity>,
 	}
 
@@ -161,13 +194,21 @@ pub mod episodes {
 		pub date: NaiveDate,
 
 		/// The show this episode belongs to
-		#[sea_orm(belongs_to, from = "show_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "show_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub show: HasOne<super::shows::Entity>,
 		/// The season this episode belongs to
 		#[sea_orm(
 			belongs_to,
 			from = "(show_id, season_number)",
-			to = "(show_id, season_number)"
+			to = "(show_id, season_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub season: HasOne<super::seasons::Entity>,
 	}
@@ -179,11 +220,14 @@ pub mod episodes {
 #[cfg(test)]
 pub mod test {
 	macro_rules! make_info_collection {
-		($db:expr, $id:literal) => {
+		($db:expr, $id:expr) => {
 			$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()),
+				sort_title: Set(::std::string::String::new()),
+				fs_slug: Set(format!("C FS {}", $id)),
+				web_slug: Set(format!("C Web {}", $id)),
 			}
 			.insert($db)
 			.await
@@ -193,13 +237,16 @@ pub mod test {
 	pub(crate) use make_info_collection;
 
 	macro_rules! make_info_movie {
-		($db:expr, $id:literal) => {
+		($db:expr, $id:expr) => {
 			$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(1, 1).expect("from_yo_opt")),
+				sort_title: Set(::std::string::String::new()),
+				fs_slug: Set(format!("M FS {}", $id)),
+				web_slug: Set(format!("M Web {}", $id)),
 			}
 			.insert($db)
 			.await
@@ -209,13 +256,16 @@ pub mod test {
 	pub(crate) use make_info_movie;
 
 	macro_rules! make_info_show {
-		($db:expr, $id:literal) => {
+		($db:expr, $id:expr) => {
 			$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(1, 1).expect("from_yo_opt")),
+				sort_title: Set(::std::string::String::new()),
+				fs_slug: Set(format!("S FS {}", $id)),
+				web_slug: Set(format!("S Web {}", $id)),
 			}
 			.insert($db)
 			.await
@@ -225,10 +275,10 @@ pub mod test {
 	pub(crate) use make_info_show;
 
 	macro_rules! make_info_season {
-		($db:expr, $show:literal, $season:literal) => {
+		($db:expr, $show:expr, $season:expr) => {
 			$crate::entity::info::seasons::ActiveModel {
 				show_id: Set(::flix_model::id::ShowId::from_raw($show)),
-				season_number: Set($season),
+				season_number: Set(::flix_model::numbers::SeasonNumber::new($season)),
 				title: Set(::std::string::String::new()),
 				overview: Set(::std::string::String::new()),
 				date: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
@@ -241,11 +291,11 @@ pub mod test {
 	pub(crate) use make_info_season;
 
 	macro_rules! make_info_episode {
-		($db:expr, $show:literal, $season:literal, $episode:literal) => {
+		($db:expr, $show:expr, $season:expr, $episode:expr) => {
 			$crate::entity::info::episodes::ActiveModel {
 				show_id: Set(::flix_model::id::ShowId::from_raw($show)),
-				season_number: Set($season),
+				season_number: Set(::flix_model::numbers::SeasonNumber::new($season)),
-				episode_number: Set($episode),
+				episode_number: Set(::flix_model::numbers::EpisodeNumber::new($episode)),
 				title: Set(::std::string::String::new()),
 				overview: Set(::std::string::String::new()),
 				date: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
@@ -310,6 +360,9 @@ mod tests {
 					id: notsettable!(id, CollectionId::from_raw($id) $(, $($skip),+)?),
 					title: notsettable!(title, concat!("C Title ", $id).to_string() $(, $($skip),+)?),
 					overview: notsettable!(overview, concat!("C Overview ", $id).to_string() $(, $($skip),+)?),
+					sort_title: notsettable!(sort_title, concat!("C Sort Title ", $id).to_string() $(, $($skip),+)?),
+					fs_slug: notsettable!(fs_slug, concat!("C FS Slug ", $id).to_string() $(, $($skip),+)?),
+					web_slug: notsettable!(web_slug, concat!("C Web Slug ", $id).to_string() $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}
@@ -321,6 +374,9 @@ mod tests {
 		assert_collection!(&db, 3, Success; id);
 		assert_collection!(&db, 4, NotNullViolation; title);
 		assert_collection!(&db, 5, NotNullViolation; overview);
+		assert_collection!(&db, 6, NotNullViolation; sort_title);
+		assert_collection!(&db, 7, NotNullViolation; fs_slug);
+		assert_collection!(&db, 8, NotNullViolation; web_slug);
 	}
 
 	#[tokio::test]
@@ -351,6 +407,9 @@ mod tests {
 					tagline: notsettable!(tagline, concat!("M Tagline ", $id).to_string() $(, $($skip),+)?),
 					overview: notsettable!(overview, concat!("M Overview ", $id).to_string() $(, $($skip),+)?),
 					date: notsettable!(date, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt") $(, $($skip),+)?),
+					sort_title: notsettable!(sort_title, concat!("M Sort Title ", $id).to_string() $(, $($skip),+)?),
+					fs_slug: notsettable!(fs_slug, concat!("M FS Slug ", $id).to_string() $(, $($skip),+)?),
+					web_slug: notsettable!(web_slug, concat!("M Web Slug ", $id).to_string() $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}
@@ -364,6 +423,9 @@ mod tests {
 		assert_movie!(&db, 5, NotNullViolation; tagline);
 		assert_movie!(&db, 6, NotNullViolation; overview);
 		assert_movie!(&db, 7, NotNullViolation; date);
+		assert_movie!(&db, 8, NotNullViolation; sort_title);
+		assert_movie!(&db, 9, NotNullViolation; fs_slug);
+		assert_movie!(&db, 10, NotNullViolation; web_slug);
 	}
 
 	#[tokio::test]
@@ -397,6 +459,9 @@ mod tests {
 					tagline: notsettable!(tagline, concat!("S Tagline ", $id).to_string() $(, $($skip),+)?),
 					overview: notsettable!(overview, concat!("S Overview ", $id).to_string() $(, $($skip),+)?),
 					date: notsettable!(date, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt") $(, $($skip),+)?),
+					sort_title: notsettable!(sort_title, concat!("S Sort Title ", $id).to_string() $(, $($skip),+)?),
+					fs_slug: notsettable!(fs_slug, concat!("S FS Slug ", $id).to_string() $(, $($skip),+)?),
+					web_slug: notsettable!(web_slug, concat!("S Web Slug ", $id).to_string() $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}
@@ -410,6 +475,9 @@ mod tests {
 		assert_show!(&db, 5, NotNullViolation; tagline);
 		assert_show!(&db, 6, NotNullViolation; overview);
 		assert_show!(&db, 7, NotNullViolation; date);
+		assert_show!(&db, 8, NotNullViolation; sort_title);
+		assert_show!(&db, 9, NotNullViolation; fs_slug);
+		assert_show!(&db, 10, NotNullViolation; web_slug);
 	}
 
 	#[tokio::test]
@@ -422,7 +490,7 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.show_id, ShowId::from_raw($show));
-				assert_eq!(model.season_number, $season);
+				assert_eq!(model.season_number, ::flix_model::numbers::SeasonNumber::new($season));
 				assert_eq!(model.title, concat!("SS Title ", $show, ",", $season));
 				assert_eq!(model.overview, concat!("SS Overview ", $show, ",", $season));
 				assert_eq!(model.date, NaiveDate::from_yo_opt($show + $season, 1).expect("from_yo_opt"));
@@ -439,7 +507,7 @@ mod tests {
 			(@insert, $db:expr, $show:literal, $season:literal $(; $($skip:ident),+)?) => {
 				super::seasons::ActiveModel {
 					show_id: notsettable!(show_id, ShowId::from_raw($show) $(, $($skip),+)?),
-					season_number: notsettable!(season_number, $season $(, $($skip),+)?),
+					season_number: notsettable!(season_number, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
 					title: notsettable!(title, concat!("SS Title ", $show, ",", $season).to_string() $(, $($skip),+)?),
 					overview: notsettable!(overview, concat!("SS Overview ", $show, ",", $season).to_string() $(, $($skip),+)?),
 					date: notsettable!(date, NaiveDate::from_yo_opt($show + $season, 1).expect("from_yo_opt") $(, $($skip),+)?),
@@ -473,8 +541,8 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.show_id, ShowId::from_raw($show));
-				assert_eq!(model.season_number, $season);
+				assert_eq!(model.season_number, ::flix_model::numbers::SeasonNumber::new($season));
-				assert_eq!(model.episode_number, $episode);
+				assert_eq!(model.episode_number, ::flix_model::numbers::EpisodeNumber::new($episode));
 				assert_eq!(model.title, concat!("SSE Title ", $show, ",", $season, ",", $episode));
 				assert_eq!(model.overview, concat!("SSE Overview ", $show, ",", $season, ",", $episode));
 				assert_eq!(model.date, NaiveDate::from_yo_opt($show + $season, 1).expect("from_yo_opt"));
@@ -491,8 +559,8 @@ mod tests {
 			(@insert, $db:expr, $show:literal, $season:literal, $episode:literal $(; $($skip:ident),+)?) => {
 				super::episodes::ActiveModel {
 					show_id: notsettable!(show_id, ShowId::from_raw($show) $(, $($skip),+)?),
-					season_number: notsettable!(season_number, $season $(, $($skip),+)?),
+					season_number: notsettable!(season_number, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
-					episode_number: notsettable!(episode_number, $episode $(, $($skip),+)?),
+					episode_number: notsettable!(episode_number, ::flix_model::numbers::EpisodeNumber::new($episode) $(, $($skip),+)?),
 					title: notsettable!(title, concat!("SSE Title ", $show, ",", $season, ",", $episode).to_string() $(, $($skip),+)?),
 					overview: notsettable!(overview, concat!("SSE Overview ", $show, ",", $season, ",", $episode).to_string() $(, $($skip),+)?),
 					date: notsettable!(date, NaiveDate::from_yo_opt($show + $season, 1).expect("from_yo_opt") $(, $($skip),+)?),

crates/db/src/entity/tmdb.rs

@@ -5,7 +5,7 @@ pub mod collections {
 	use flix_model::id::CollectionId as FlixId;
 	use flix_tmdb::model::id::CollectionId;
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -16,22 +16,29 @@ pub mod collections {
 	#[sea_orm(table_name = "flix_tmdb_collections")]
 	pub struct Model {
 		/// The collection's TMDB ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub tmdb_id: CollectionId,
 		/// The collection's ID
 		#[sea_orm(unique)]
 		pub flix_id: FlixId,
 		/// The date of the last update
-		pub last_update: NaiveDate,
+		pub last_update: DateTime<Utc>,
 		/// The number of movies in the collection
 		pub movie_count: u16,
 
-		/// Movies that are in this collection
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
-		pub movies: HasMany<super::movies::Entity>,
 		/// The info for this collection
-		#[sea_orm(belongs_to, from = "flix_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "flix_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::collections::Entity>,
+
+		/// Movies that are in this collection
+		#[sea_orm(has_many)]
+		pub movies: HasMany<super::movies::Entity>,
 	}
 
 	impl ActiveModelBehavior for ActiveModel {}
@@ -44,7 +51,7 @@ pub mod movies {
 
 	use seamantic::model::duration::Seconds;
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -55,24 +62,36 @@ pub mod movies {
 	#[sea_orm(table_name = "flix_tmdb_movies")]
 	pub struct Model {
 		/// The movie's TMDB ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub tmdb_id: MovieId,
 		/// The movie's ID
 		#[sea_orm(unique)]
 		pub flix_id: FlixId,
 		/// The date of the last update
-		pub last_update: NaiveDate,
+		pub last_update: DateTime<Utc>,
 		/// The movie's runtime in seconds
 		pub runtime: Seconds,
 		/// The TMDB ID of the collection this movie belongs to
 		#[sea_orm(indexed)]
 		pub collection_id: Option<CollectionId>,
 
-		/// The info for this collection
+		/// The collection this movie belongs to
-		#[sea_orm(belongs_to, from = "collection_id", to = "tmdb_id")]
+		#[sea_orm(
+			belongs_to,
+			from = "collection_id",
+			to = "tmdb_id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub collection: HasOne<super::collections::Entity>,
 		/// The info for this movie
-		#[sea_orm(belongs_to, from = "flix_id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "flix_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::movies::Entity>,
 	}
 
@@ -84,7 +103,7 @@ pub mod shows {
 	use flix_model::id::ShowId as FlixId;
 	use flix_tmdb::model::id::ShowId;
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -95,25 +114,32 @@ pub mod shows {
 	#[sea_orm(table_name = "flix_tmdb_shows")]
 	pub struct Model {
 		/// The show's TMDB ID
-		#[sea_orm(column_type = "Integer", primary_key, nullable, auto_increment = false)]
+		#[sea_orm(primary_key, auto_increment = false)]
 		pub tmdb_id: ShowId,
 		/// The show's ID
 		#[sea_orm(unique)]
 		pub flix_id: FlixId,
 		/// The movie's runtime in seconds
-		pub last_update: NaiveDate,
+		pub last_update: DateTime<Utc>,
 		/// The number of seasons the show has
 		pub number_of_seasons: u32,
 
+		/// The info for this show
+		#[sea_orm(
+			belongs_to,
+			from = "flix_id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
+		pub info: HasOne<entity::info::shows::Entity>,
+
 		/// Seasons that are part of this show
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub seasons: HasMany<super::seasons::Entity>,
 		/// Episodes that are part of this show
-		#[sea_orm(has_many, on_update = "Cascade", on_delete = "Cascade")]
+		#[sea_orm(has_many)]
 		pub episodes: HasMany<super::episodes::Entity>,
-		/// The info for this show
-		#[sea_orm(belongs_to, from = "flix_id", to = "id")]
-		pub info: HasOne<entity::info::shows::Entity>,
 	}
 
 	impl ActiveModelBehavior for ActiveModel {}
@@ -125,7 +151,7 @@ pub mod seasons {
 	use flix_model::numbers::SeasonNumber;
 	use flix_tmdb::model::id::ShowId;
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -148,18 +174,30 @@ pub mod seasons {
 		#[sea_orm(unique_key = "flix")]
 		pub flix_season: SeasonNumber,
 		/// The date of the last update
-		pub last_update: NaiveDate,
+		pub last_update: DateTime<Utc>,
 
 		/// The show this season belongs to
-		#[sea_orm(belongs_to, from = "tmdb_show", to = "tmdb_id")]
+		#[sea_orm(
+			belongs_to,
+			from = "tmdb_show",
+			to = "tmdb_id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub show: HasOne<super::shows::Entity>,
 		/// The info for this season
 		#[sea_orm(
 			belongs_to,
 			from = "(flix_show, flix_season)",
-			to = "(show_id, season_number)"
+			to = "(show_id, season_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub info: HasOne<entity::info::seasons::Entity>,
+
+		/// Episodes that are part of this season
+		#[sea_orm(has_many)]
+		pub episodes: HasMany<super::episodes::Entity>,
 	}
 
 	impl ActiveModelBehavior for ActiveModel {}
@@ -172,7 +210,7 @@ pub mod episodes {
 	use flix_tmdb::model::id::ShowId;
 	use seamantic::model::duration::Seconds;
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -201,25 +239,35 @@ pub mod episodes {
 		#[sea_orm(unique_key = "flix")]
 		pub flix_episode: EpisodeNumber,
 		/// The date of the last update
-		pub last_update: NaiveDate,
+		pub last_update: DateTime<Utc>,
 		/// The episode's runtime in seconds
 		pub runtime: Seconds,
 
 		/// The show this episode belongs to
-		#[sea_orm(belongs_to, from = "tmdb_show", to = "tmdb_id")]
+		#[sea_orm(
+			belongs_to,
+			from = "tmdb_show",
+			to = "tmdb_id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub show: HasOne<super::shows::Entity>,
 		/// The season this episode belongs to
 		#[sea_orm(
 			belongs_to,
 			from = "(tmdb_show, tmdb_season)",
-			to = "(tmdb_show, tmdb_season)"
+			to = "(tmdb_show, tmdb_season)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub season: HasOne<super::seasons::Entity>,
 		/// The info for this episode
 		#[sea_orm(
 			belongs_to,
 			from = "(flix_show, flix_season, flix_episode)",
-			to = "(show_id, season_number, episode_number)"
+			to = "(show_id, season_number, episode_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub info: HasOne<entity::info::episodes::Entity>,
 	}
@@ -231,11 +279,11 @@ pub mod episodes {
 #[cfg(test)]
 pub mod test {
 	macro_rules! make_tmdb_collection {
-		($db:expr, $id:literal, $flix_id:literal) => {
+		($db:expr, $id:expr, $flix_id:expr) => {
 			$crate::entity::tmdb::collections::ActiveModel {
 				tmdb_id: Set(::flix_tmdb::model::id::CollectionId::from_raw($id)),
 				flix_id: Set(::flix_model::id::CollectionId::from_raw($flix_id)),
-				last_update: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				last_update: Set(::chrono::Utc::now()),
 				movie_count: Set(::core::default::Default::default()),
 			}
 			.insert($db)
@@ -246,11 +294,11 @@ pub mod test {
 	pub(crate) use make_tmdb_collection;
 
 	macro_rules! make_tmdb_movie {
-		($db:expr, $id:literal, $flix_id:literal) => {
+		($db:expr, $id:expr, $flix_id:expr) => {
 			$crate::entity::tmdb::movies::ActiveModel {
 				tmdb_id: Set(::flix_tmdb::model::id::MovieId::from_raw($id)),
 				flix_id: Set(::flix_model::id::MovieId::from_raw($flix_id)),
-				last_update: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				last_update: Set(::chrono::Utc::now()),
 				runtime: Set(::core::default::Default::default()),
 				collection_id: Set(None),
 			}
@@ -262,11 +310,11 @@ pub mod test {
 	pub(crate) use make_tmdb_movie;
 
 	macro_rules! make_tmdb_show {
-		($db:expr, $id:literal, $flix_id:literal) => {
+		($db:expr, $id:expr, $flix_id:expr) => {
 			$crate::entity::tmdb::shows::ActiveModel {
 				tmdb_id: Set(::flix_tmdb::model::id::ShowId::from_raw($id)),
 				flix_id: Set(::flix_model::id::ShowId::from_raw($flix_id)),
-				last_update: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				last_update: Set(::chrono::Utc::now()),
 				number_of_seasons: Set(::core::default::Default::default()),
 			}
 			.insert($db)
@@ -277,13 +325,13 @@ pub mod test {
 	pub(crate) use make_tmdb_show;
 
 	macro_rules! make_tmdb_season {
-		($db:expr, $show:literal, $season:literal, $flix_show:literal, $flix_season:literal) => {
+		($db:expr, $show:expr, $season:expr, $flix_show:expr, $flix_season:expr) => {
 			$crate::entity::tmdb::seasons::ActiveModel {
 				tmdb_show: Set(::flix_tmdb::model::id::ShowId::from_raw($show)),
-				tmdb_season: Set($season),
+				tmdb_season: Set(::flix_model::numbers::SeasonNumber::new($season)),
 				flix_show: Set(::flix_model::id::ShowId::from_raw($flix_show)),
-				flix_season: Set($flix_season),
+				flix_season: Set(::flix_model::numbers::SeasonNumber::new($flix_season)),
-				last_update: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				last_update: Set(::chrono::Utc::now()),
 			}
 			.insert($db)
 			.await
@@ -293,15 +341,15 @@ pub mod test {
 	pub(crate) use make_tmdb_season;
 
 	macro_rules! make_tmdb_episode {
-		($db:expr, $show:literal, $season:literal, $episode:literal, $flix_show:literal, $flix_season:literal, $flix_episode:literal) => {
+		($db:expr, $show:expr, $season:expr, $episode:expr, $flix_show:expr, $flix_season:expr, $flix_episode:expr) => {
 			$crate::entity::tmdb::episodes::ActiveModel {
 				tmdb_show: Set(::flix_tmdb::model::id::ShowId::from_raw($show)),
-				tmdb_season: Set($season),
+				tmdb_season: Set(::flix_model::numbers::SeasonNumber::new($season)),
-				tmdb_episode: Set($episode),
+				tmdb_episode: Set(::flix_model::numbers::EpisodeNumber::new($episode)),
 				flix_show: Set(::flix_model::id::ShowId::from_raw($flix_show)),
-				flix_season: Set($flix_season),
+				flix_season: Set(::flix_model::numbers::SeasonNumber::new($flix_season)),
-				flix_episode: Set($flix_episode),
+				flix_episode: Set(::flix_model::numbers::EpisodeNumber::new($flix_episode)),
-				last_update: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				last_update: Set(::chrono::Utc::now()),
 				runtime: Set(::core::default::Default::default()),
 			}
 			.insert($db)
@@ -365,7 +413,7 @@ mod tests {
 
 				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($id, 1).expect("from_yo_opt"));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 				assert_eq!(model.movie_count, $id);
 			};
 			($db:expr, $id:literal, $tid:literal, $error:ident $(; $($skip:ident),+)?) => {
@@ -378,7 +426,7 @@ mod tests {
 				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($id, 1).expect("from_yo_opt") $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 					movie_count: notsettable!(movie_count, $id $(, $($skip),+)?),
 				}.insert($db).await
 			};
@@ -412,7 +460,7 @@ mod tests {
 
 				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($id, 1).expect("from_yo_opt"));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 				assert_eq!(model.runtime, Duration::from_secs($tid).into());
 				assert_eq!(model.collection_id, $cid.map(TmdbCollectionId::from_raw));
 			};
@@ -426,7 +474,7 @@ mod tests {
 				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($id, 1).expect("from_yo_opt") $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt($id, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 					runtime: notsettable!(runtime, Duration::from_secs($tid).into() $(, $($skip),+)?),
 					collection_id: notsettable!(collection_id, $cid.map(TmdbCollectionId::from_raw) $(, $($skip),+)?),
 				}.insert($db).await
@@ -465,7 +513,7 @@ mod tests {
 
 				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.last_update, NaiveDate::from_yo_opt($tid, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 				assert_eq!(model.number_of_seasons, $id);
 			};
 			($db:expr, $id:literal, $tid:literal, $error:ident $(; $($skip:ident),+)?) => {
@@ -481,7 +529,7 @@ mod tests {
 				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),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt($tid, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 					number_of_seasons: notsettable!(number_of_seasons, $id $(, $($skip),+)?),
 				}.insert($db).await
 			};
@@ -514,10 +562,10 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.tmdb_show, TmdbShowId::from_raw($tshow));
-				assert_eq!(model.tmdb_season, $tseason);
+				assert_eq!(model.tmdb_season, ::flix_model::numbers::SeasonNumber::new($tseason));
 				assert_eq!(model.flix_show, ShowId::from_raw($show));
-				assert_eq!(model.flix_season, $season);
+				assert_eq!(model.flix_season, ::flix_model::numbers::SeasonNumber::new($season));
-				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt"));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt($tshow, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 			};
 			($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),+)?)
@@ -531,10 +579,10 @@ mod tests {
 			(@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),+)?),
+					tmdb_season: notsettable!(tmdb_season, ::flix_model::numbers::SeasonNumber::new($tseason) $(, $($skip),+)?),
 					flix_show: notsettable!(flix_show, ShowId::from_raw($show) $(, $($skip),+)?),
-					flix_season: notsettable!(flix_season, $season $(, $($skip),+)?),
+					flix_season: notsettable!(flix_season, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
-					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt($tshow, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}
@@ -569,12 +617,12 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.tmdb_show, TmdbShowId::from_raw($tshow));
-				assert_eq!(model.tmdb_season, $tseason);
+				assert_eq!(model.tmdb_season, ::flix_model::numbers::SeasonNumber::new($tseason));
-				assert_eq!(model.tmdb_episode, $tepisode);
+				assert_eq!(model.tmdb_episode, ::flix_model::numbers::EpisodeNumber::new($tepisode));
 				assert_eq!(model.flix_show, ShowId::from_raw($show));
-				assert_eq!(model.flix_season, $season);
+				assert_eq!(model.flix_season, ::flix_model::numbers::SeasonNumber::new($season));
-				assert_eq!(model.flix_episode, $episode);
+				assert_eq!(model.flix_episode, ::flix_model::numbers::EpisodeNumber::new($episode));
-				assert_eq!(model.last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt"));
+				assert_eq!(model.last_update, NaiveDate::from_yo_opt($tshow, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 				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),+)?) => {
@@ -589,12 +637,12 @@ mod tests {
 			(@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_season: notsettable!(tmdb_season, ::flix_model::numbers::SeasonNumber::new($tseason) $(, $($skip),+)?),
-					tmdb_episode: notsettable!(tmdb_episode, $tepisode $(, $($skip),+)?),
+					tmdb_episode: notsettable!(tmdb_episode, ::flix_model::numbers::EpisodeNumber::new($tepisode) $(, $($skip),+)?),
 					flix_show: notsettable!(flix_show, ShowId::from_raw($show) $(, $($skip),+)?),
-					flix_season: notsettable!(flix_season, $season $(, $($skip),+)?),
+					flix_season: notsettable!(flix_season, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
-					flix_episode: notsettable!(flix_episode, $episode $(, $($skip),+)?),
+					flix_episode: notsettable!(flix_episode, ::flix_model::numbers::EpisodeNumber::new($episode) $(, $($skip),+)?),
-					last_update: notsettable!(last_update, NaiveDate::from_yo_opt(2000, $tshow).expect("NaiveDate::from_yo_opt") $(, $($skip),+)?),
+					last_update: notsettable!(last_update, NaiveDate::from_yo_opt($tshow, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 					runtime: notsettable!(runtime, Duration::from_secs($tshow).into() $(, $($skip),+)?),
 				}.insert($db).await
 			};

crates/db/src/entity/watched.rs

@@ -4,7 +4,7 @@
 pub mod collections {
 	use flix_model::id::{CollectionId, RawId};
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -21,10 +21,17 @@ pub mod collections {
 		#[sea_orm(primary_key, auto_increment = false)]
 		pub user_id: RawId,
 		/// The date this collection was watched
-		pub watched_date: NaiveDate,
+		pub watched_date: DateTime<Utc>,
 
 		/// The info for this collection
-		#[sea_orm(belongs_to, relation_enum = "Info", from = "id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			relation_enum = "Info",
+			from = "id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::collections::Entity>,
 		/// The content for this collection
 		#[sea_orm(belongs_to, relation_enum = "Content", from = "id", to = "id", skip_fk)]
@@ -38,7 +45,7 @@ pub mod collections {
 pub mod movies {
 	use flix_model::id::{MovieId, RawId};
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -55,10 +62,16 @@ pub mod movies {
 		#[sea_orm(primary_key, auto_increment = false)]
 		pub user_id: RawId,
 		/// The date this movie was watched
-		pub watched_date: NaiveDate,
+		pub watched_date: DateTime<Utc>,
 
 		/// The info for this movie
-		#[sea_orm(belongs_to, from = "id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			from = "id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::movies::Entity>,
 		/// The content for this movie
 		#[sea_orm(belongs_to, relation_enum = "Content", from = "id", to = "id", skip_fk)]
@@ -72,7 +85,7 @@ pub mod movies {
 pub mod shows {
 	use flix_model::id::{RawId, ShowId};
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -89,10 +102,17 @@ pub mod shows {
 		#[sea_orm(primary_key, auto_increment = false)]
 		pub user_id: RawId,
 		/// The date this show was watched
-		pub watched_date: NaiveDate,
+		pub watched_date: DateTime<Utc>,
 
 		/// The info for this show
-		#[sea_orm(belongs_to, relation_enum = "Info", from = "id", to = "id")]
+		#[sea_orm(
+			belongs_to,
+			relation_enum = "Info",
+			from = "id",
+			to = "id",
+			on_update = "Cascade",
+			on_delete = "Cascade"
+		)]
 		pub info: HasOne<entity::info::shows::Entity>,
 		/// The content for this show
 		#[sea_orm(belongs_to, relation_enum = "Content", from = "id", to = "id", skip_fk)]
@@ -107,7 +127,7 @@ pub mod seasons {
 	use flix_model::id::{RawId, ShowId};
 	use flix_model::numbers::SeasonNumber;
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -127,14 +147,16 @@ pub mod seasons {
 		#[sea_orm(primary_key, auto_increment = false)]
 		pub user_id: RawId,
 		/// The date this season was watched
-		pub watched_date: NaiveDate,
+		pub watched_date: DateTime<Utc>,
 
 		/// The info for this season
 		#[sea_orm(
 			belongs_to,
 			relation_enum = "Info",
 			from = "(show_id, season_number)",
-			to = "(show_id, season_number)"
+			to = "(show_id, season_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub info: HasOne<entity::info::seasons::Entity>,
 		/// The content for this season
@@ -156,7 +178,7 @@ pub mod episodes {
 	use flix_model::id::{RawId, ShowId};
 	use flix_model::numbers::{EpisodeNumber, SeasonNumber};
 
-	use chrono::NaiveDate;
+	use chrono::{DateTime, Utc};
 	use sea_orm::entity::prelude::*;
 
 	use crate::entity;
@@ -179,14 +201,16 @@ pub mod episodes {
 		#[sea_orm(primary_key, auto_increment = false)]
 		pub user_id: RawId,
 		/// The date this episode was watched
-		pub watched_date: NaiveDate,
+		pub watched_date: DateTime<Utc>,
 
 		/// The info for this episode
 		#[sea_orm(
 			belongs_to,
 			relation_enum = "Info",
 			from = "(show_id, season_number, episode_number)",
-			to = "(show_id, season_number, episode_number)"
+			to = "(show_id, season_number, episode_number)",
+			on_update = "Cascade",
+			on_delete = "Cascade"
 		)]
 		pub info: HasOne<entity::info::episodes::Entity>,
 		/// The content for this episode
@@ -207,11 +231,11 @@ pub mod episodes {
 #[cfg(test)]
 pub mod test {
 	macro_rules! make_watched_movie {
-		($db:expr, $id:literal, $user:literal) => {
+		($db:expr, $id:expr, $user:expr) => {
 			$crate::entity::watched::movies::ActiveModel {
 				id: Set(::flix_model::id::MovieId::from_raw($id)),
 				user_id: Set($user),
-				watched_date: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				watched_date: Set(::chrono::Utc::now()),
 			}
 			.insert($db)
 			.await
@@ -221,13 +245,13 @@ pub mod test {
 	pub(crate) use make_watched_movie;
 
 	macro_rules! make_watched_episode {
-		($db:expr, $show:literal, $season:literal, $episode:literal, $user:literal) => {
+		($db:expr, $show:expr, $season:expr, $episode:expr, $user:expr) => {
 			$crate::entity::watched::episodes::ActiveModel {
 				show_id: Set(::flix_model::id::ShowId::from_raw($show)),
-				season_number: Set($season),
+				season_number: Set(::flix_model::numbers::SeasonNumber::new($season)),
-				episode_number: Set($episode),
+				episode_number: Set(::flix_model::numbers::EpisodeNumber::new($episode)),
 				user_id: Set($user),
-				watched_date: Set(::chrono::NaiveDate::from_yo_opt(1, 1).expect("from_yo_opt")),
+				watched_date: Set(::chrono::Utc::now()),
 			}
 			.insert($db)
 			.await
@@ -284,7 +308,7 @@ mod tests {
 
 				assert_eq!(model.id, MovieId::from_raw($id));
 				assert_eq!(model.user_id, $uid);
-				assert_eq!(model.watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt"));
+				assert_eq!(model.watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 			};
 			($db:expr, $id:literal, $uid:literal, $error:ident $(; $($skip:ident),+)?) => {
 				let model = assert_movie!(@insert, $db, $id, $uid $(; $($skip),+)?)
@@ -296,7 +320,7 @@ mod tests {
 				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($uid, 1).expect("from_yo_opt") $(, $($skip),+)?),
+					watched_date: notsettable!(watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}
@@ -326,10 +350,10 @@ mod tests {
 					.expect("insert");
 
 				assert_eq!(model.show_id, ShowId::from_raw($show));
-				assert_eq!(model.season_number, $season);
+				assert_eq!(model.season_number, ::flix_model::numbers::SeasonNumber::new($season));
-				assert_eq!(model.episode_number, $episode);
+				assert_eq!(model.episode_number, ::flix_model::numbers::EpisodeNumber::new($episode));
 				assert_eq!(model.user_id, $uid);
-				assert_eq!(model.watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt"));
+				assert_eq!(model.watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc());
 			};
 			($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),+)?)
@@ -340,10 +364,10 @@ mod tests {
 			(@insert, $db:expr, $show:literal, $season:literal, $episode:literal, $uid:literal $(; $($skip:ident),+)?) => {
 				super::episodes::ActiveModel {
 					show_id: notsettable!(show_id, ShowId::from_raw($show) $(, $($skip),+)?),
-					season_number: notsettable!(season_number, $season $(, $($skip),+)?),
+					season_number: notsettable!(season_number, ::flix_model::numbers::SeasonNumber::new($season) $(, $($skip),+)?),
-					episode_number: notsettable!(episode_number, $episode $(, $($skip),+)?),
+					episode_number: notsettable!(episode_number, ::flix_model::numbers::EpisodeNumber::new($episode) $(, $($skip),+)?),
 					user_id: notsettable!(user_id, $uid $(, $($skip),+)?),
-					watched_date: notsettable!(watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt") $(, $($skip),+)?),
+					watched_date: notsettable!(watched_date, NaiveDate::from_yo_opt($uid, 1).expect("from_yo_opt").and_hms_opt(0, 0, 0).expect("and_hms_opt").and_utc() $(, $($skip),+)?),
 				}.insert($db).await
 			};
 		}

crates/flix/Cargo.toml

@@ -1,22 +1,22 @@
 [package]
 name = "flix"
-version = "0.0.14"
+version = "0.0.16"
-
+edition.workspace = true
-categories = []
+rust-version.workspace = true
 description = "Mechanisms for interacting with flix media"
 repository = "https://github.com/QuantumShade/flix"
-
-authors.workspace = true
-edition.workspace = true
 license-file.workspace = true
-rust-version.workspace = true
+categories = []
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints]
+[dependencies]
-workspace = true
+flix-db = { workspace = true }
+flix-fs = { workspace = true, optional = true }
+flix-model = { workspace = true }
+flix-tmdb = { workspace = true, optional = true }
 
 [features]
 default = []
@@ -24,9 +24,5 @@ fs = ["dep:flix-fs"]
 serde = ["flix-model/serde"]
 tmdb = ["dep:flix-tmdb", "flix-db/tmdb"]
 
-[dependencies]
+[lints]
-flix-db = { workspace = true }
+workspace = true
-flix-model = { workspace = true }
-
-flix-fs = { workspace = true, optional = true }
-flix-tmdb = { workspace = true, optional = true }

crates/fs/Cargo.toml

@@ -1,28 +1,24 @@
 [package]
 name = "flix-fs"
-version = "0.0.14"
+version = "0.0.16"
-
+edition.workspace = true
-categories = []
+rust-version.workspace = true
 description = "Filesystem scanner for flix media"
 repository = "https://github.com/QuantumShade/flix"
-
-authors.workspace = true
-edition.workspace = true
 license-file.workspace = true
-rust-version.workspace = true
+categories = []
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints]
-workspace = true
-
 [dependencies]
-flix-model = { workspace = true }
-
 async-stream = { workspace = true }
-regex = { workspace = true, features = ["std", "perf"] }
+flix-model = { workspace = true }
+regex = { workspace = true, features = ["perf", "std"] }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tokio-stream = { workspace = true, features = ["fs"] }
+
+[lints]
+workspace = true

crates/fs/src/scanner/collection.rs

@@ -215,18 +215,19 @@ impl Scanner {
 			for await dir in ReadDirStream::new(dirs) {
 				match dir {
 					Ok(dir) => {
+						let path = dir.path();
+
 						let filetype = match dir.file_type().await {
 							Ok(filetype) => filetype,
 							Err(err) => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::FileType(err)),
 								};
 								continue;
 							}
 						};
 
-						let path = dir.path();
 						if filetype.is_dir() {
 							subdirs_to_scan.push(path);
 							continue;
@@ -236,7 +237,7 @@ impl Scanner {
 							is_image_extension!() => {
 								if poster_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicatePosterFile),
 									};
 									continue;
@@ -248,7 +249,7 @@ impl Scanner {
 							}
 							Some(_) | None => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::UnexpectedFile),
 								};
 							}

crates/fs/src/scanner/episode.rs

@@ -60,11 +60,13 @@ impl Scanner {
 			for await dir in ReadDirStream::new(dirs) {
 				match dir {
 					Ok(dir) => {
+						let path = dir.path();
+
 						let filetype = match dir.file_type().await {
 							Ok(filetype) => filetype,
 							Err(err) => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::FileType(err)),
 								};
 								continue;
@@ -72,18 +74,17 @@ impl Scanner {
 						};
 						if !filetype.is_file() {
 							yield Item {
-								path: path.to_owned(),
+								path,
 								event: Err(Error::UnexpectedNonFile),
 							};
 							continue;
 						}
 
-						let path = dir.path();
 						match path.extension().and_then(OsStr::to_str) {
 							is_media_extension!() => {
 								if media_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicateMediaFile),
 									};
 									continue;
@@ -97,7 +98,7 @@ impl Scanner {
 							is_image_extension!() => {
 								if poster_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicatePosterFile),
 									};
 									continue;
@@ -109,7 +110,7 @@ impl Scanner {
 							}
 							Some(_) | None => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::UnexpectedFile),
 								};
 							}

crates/fs/src/scanner/generic.rs

@@ -211,7 +211,7 @@ impl Scanner {
 		}
 
 		let media_folder_re = MEDIA_FOLDER_REGEX.get_or_init(|| {
-			Regex::new(r"^[[[:alnum:]] -]+ \([[:digit:]]+\) \[[[:digit:]]+\]$")
+			Regex::new(r"^[[[:alnum:]]' -]+ \([[:digit:]]+\) \[[[:digit:]]+\]$")
 				.unwrap_or_else(|err| panic!("regex is invalid: {err}"))
 		});
 		let season_folder_re = SEASON_FOLDER_REGEX.get_or_init(|| {
@@ -257,11 +257,13 @@ impl Scanner {
 				for await dir in ReadDirStream::new(dirs) {
 					match dir {
 						Ok(dir) => {
+							let path = dir.path();
+
 							let filetype = match dir.file_type().await {
 								Ok(filetype) => filetype,
 								Err(err) => {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::FileType(err)),
 									};
 									continue;
@@ -271,11 +273,9 @@ impl Scanner {
 								continue;
 							}
 
-							let dir_path = dir.path();
+							let Some(folder_name) = path.file_name().and_then(OsStr::to_str) else {
-							let Some(folder_name) = dir_path.file_name().and_then(OsStr::to_str)
-							else {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::UnexpectedFolder),
 								};
 								continue;

crates/fs/src/scanner/movie.rs

@@ -56,11 +56,13 @@ impl Scanner {
 			for await dir in ReadDirStream::new(dirs) {
 				match dir {
 					Ok(dir) => {
+						let path = dir.path();
+
 						let filetype = match dir.file_type().await {
 							Ok(filetype) => filetype,
 							Err(err) => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::FileType(err)),
 								};
 								continue;
@@ -68,18 +70,17 @@ impl Scanner {
 						};
 						if !filetype.is_file() {
 							yield Item {
-								path: path.to_owned(),
+								path,
 								event: Err(Error::UnexpectedNonFile),
 							};
 							continue;
 						}
 
-						let path = dir.path();
 						match path.extension().and_then(OsStr::to_str) {
 							is_media_extension!() => {
 								if media_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicateMediaFile),
 									};
 									continue;
@@ -93,7 +94,7 @@ impl Scanner {
 							is_image_extension!() => {
 								if poster_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicatePosterFile),
 									};
 									continue;
@@ -105,7 +106,7 @@ impl Scanner {
 							}
 							Some(_) | None => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::UnexpectedFile),
 								};
 							}

crates/fs/src/scanner/season.rs

@@ -89,18 +89,19 @@ impl Scanner {
 			for await dir in ReadDirStream::new(dirs) {
 				match dir {
 					Ok(dir) => {
+						let path = dir.path();
+
 						let filetype = match dir.file_type().await {
 							Ok(filetype) => filetype,
 							Err(err) => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::FileType(err)),
 								};
 								continue;
 							}
 						};
 
-						let path = dir.path();
 						if filetype.is_dir() {
 							episode_dirs_to_scan.push(path);
 							continue;
@@ -110,7 +111,7 @@ impl Scanner {
 							is_image_extension!() => {
 								if poster_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicatePosterFile),
 									};
 									continue;
@@ -122,7 +123,7 @@ impl Scanner {
 							}
 							Some(_) | None => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::UnexpectedFile),
 								};
 							}
@@ -149,7 +150,7 @@ impl Scanner {
 			for episode_dir in episode_dirs_to_scan {
 				let Some(episode_dir_name) = episode_dir.file_name().and_then(OsStr::to_str) else {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;
@@ -157,14 +158,14 @@ impl Scanner {
 
 				let Some((_, s_e_str)) = episode_dir_name.split_once('S') else {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;
 				};
 				let Some((s_str, e_str)) = s_e_str.split_once('E') else {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;
@@ -172,14 +173,14 @@ impl Scanner {
 
 				let Ok(season_number) = s_str.parse::<SeasonNumber>() else {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;
 				};
 				if season_number != season {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::Inconsistent),
 					};
 					continue;
@@ -191,14 +192,14 @@ impl Scanner {
 					.collect::<Result<Vec<_>, _>>()
 				else {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;
 				};
 				let Ok(episode_numbers) = EpisodeNumbers::try_from(episode_numbers.as_ref()) else {
 					yield Item {
-						path: path.to_owned(),
+						path: episode_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;

crates/fs/src/scanner/show.rs

@@ -107,18 +107,19 @@ impl Scanner {
 			for await dir in ReadDirStream::new(dirs) {
 				match dir {
 					Ok(dir) => {
+						let path = dir.path();
+
 						let filetype = match dir.file_type().await {
 							Ok(filetype) => filetype,
 							Err(err) => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::FileType(err)),
 								};
 								continue;
 							}
 						};
 
-						let path = dir.path();
 						if filetype.is_dir() {
 							season_dirs_to_scan.push(path);
 							continue;
@@ -128,7 +129,7 @@ impl Scanner {
 							is_image_extension!() => {
 								if poster_file_name.is_some() {
 									yield Item {
-										path: path.to_owned(),
+										path,
 										event: Err(Error::DuplicatePosterFile),
 									};
 									continue;
@@ -140,7 +141,7 @@ impl Scanner {
 							}
 							Some(_) | None => {
 								yield Item {
-									path: path.to_owned(),
+									path,
 									event: Err(Error::UnexpectedFile),
 								};
 							}
@@ -167,7 +168,7 @@ impl Scanner {
 			for season_dir in season_dirs_to_scan {
 				let Some(season_dir_name) = season_dir.file_name().and_then(OsStr::to_str) else {
 					yield Item {
-						path: path.to_owned(),
+						path: season_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;
@@ -178,7 +179,7 @@ impl Scanner {
 					.map(|(_, s)| s.parse::<SeasonNumber>())
 				else {
 					yield Item {
-						path: path.to_owned(),
+						path: season_dir,
 						event: Err(Error::UnexpectedFolder),
 					};
 					continue;

crates/model/Cargo.toml

@@ -1,29 +1,26 @@
 [package]
 name = "flix-model"
-version = "0.0.14"
+version = "0.0.16"
-
+edition.workspace = true
-categories = []
+rust-version.workspace = true
 description = "Core types for flix data"
 repository = "https://github.com/QuantumShade/flix"
-
-authors.workspace = true
-edition.workspace = true
 license-file.workspace = true
-rust-version.workspace = true
+categories = []
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints]
+[dependencies]
-workspace = true
+itertools = { workspace = true }
+seamantic = { workspace = true }
+serde = { workspace = true, features = ["derive", "std"], optional = true }
+thiserror = { workspace = true }
 
 [features]
 default = []
 serde = ["dep:serde"]
 
-[dependencies]
+[lints]
-seamantic = { workspace = true }
+workspace = true
-
-serde = { workspace = true, optional = true, features = ["std", "derive"] }
-thiserror = { workspace = true }

crates/model/src/lib.rs

@@ -4,3 +4,4 @@
 
 pub mod id;
 pub mod numbers;
+pub mod text;

crates/model/src/numbers.rs

@@ -1,12 +1,76 @@
 //! This module contains season and episode numbers and related errors
 
+use core::fmt;
 use core::ops::RangeInclusive;
+use core::str::FromStr;
 use std::collections::HashSet;
 
-/// Type alias for representing season numbers
+use seamantic::sea_orm;
-pub type SeasonNumber = u32;
+
-/// Type alias for representing episode numbers
+/// Newtype for representing season numbers
-pub type EpisodeNumber = u32;
+#[derive(
+	Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, sea_orm::DeriveValueType,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+#[repr(transparent)]
+pub struct SeasonNumber(u32);
+
+impl SeasonNumber {
+	/// Create a `SeasonNumber` from an integer
+	pub fn new(value: u32) -> Self {
+		Self(value)
+	}
+}
+
+impl fmt::Display for SeasonNumber {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		self.0.fmt(f)
+	}
+}
+
+impl FromStr for SeasonNumber {
+	type Err = <u32 as FromStr>::Err;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		u32::from_str(s).map(Self)
+	}
+}
+
+/// Newtype for representing episode numbers
+#[derive(
+	Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, sea_orm::DeriveValueType,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+#[repr(transparent)]
+pub struct EpisodeNumber(u32);
+
+impl EpisodeNumber {
+	/// Create an `EpisodeNumber` from an integer
+	pub fn new(value: u32) -> Self {
+		Self(value)
+	}
+
+	/// Get the underlying value
+	pub fn into_inner(self) -> u32 {
+		self.0
+	}
+}
+
+impl fmt::Display for EpisodeNumber {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		self.0.fmt(f)
+	}
+}
+
+impl FromStr for EpisodeNumber {
+	type Err = <u32 as FromStr>::Err;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		u32::from_str(s).map(Self)
+	}
+}
 
 /// Potential errors when building EpisodeNumbers
 #[derive(Debug, thiserror::Error)]
@@ -20,7 +84,7 @@ pub enum Error {
 }
 
 /// A wrapper for handling single and multi-episode entries
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct EpisodeNumbers(RangeInclusive<EpisodeNumber>);
 
@@ -37,7 +101,7 @@ impl TryFrom<&[EpisodeNumber]> for EpisodeNumbers {
 				let max = value.iter().copied().max().unwrap_or_default();
 				let len = value.len();
 
-				if usize::try_from(max.saturating_sub(min).saturating_add(1)) != Ok(len) {
+				if usize::try_from(max.0.saturating_sub(min.0).saturating_add(1)) != Ok(len) {
 					return Err(Error::Noncontiguous);
 				}
 
@@ -53,8 +117,27 @@ impl TryFrom<&[EpisodeNumber]> for EpisodeNumbers {
 }
 
 impl EpisodeNumbers {
+	/// Create an [EpisodeNumbers] from a starting number and a count.
+	/// `count` should be zero for single episodes.
+	pub fn new(start: EpisodeNumber, count: u8) -> Self {
+		Self(start..=EpisodeNumber(start.0.saturating_add(count.into())))
+	}
+
 	/// Get the range of episodes
 	pub fn as_range(&self) -> &RangeInclusive<EpisodeNumber> {
 		&self.0
 	}
+
+	/// Render this [EpisodeNumbers] as a range. If only one episode is
+	/// is present it renders as `01`, if multiple it renders as `01-02`
+	pub fn range_string(&self) -> String {
+		let start = self.0.start();
+		let end = self.0.end();
+
+		if start == end {
+			format!("{:02}", start)
+		} else {
+			format!("{:02}-{:02}", start, end)
+		}
+	}
 }

crates/model/src/text.rs

@@ -0,0 +1,165 @@
+//! This module contains helper functions for normalizing media titles
+
+use core::iter::Peekable;
+
+use itertools::Itertools;
+
+/// # Panics
+///
+/// Panics if `input` is not ASCII.
+fn split_normalized_words(input: &str) -> impl Iterator<Item = String> {
+	if !input.is_ascii() {
+		panic!("Input is not ASCII: {input}");
+	}
+
+	input.split_ascii_whitespace().map(|s| {
+		let chars = s
+			.chars()
+			.filter(|c| c.is_ascii_alphanumeric() || *c == '-')
+			.map(|c| c.to_ascii_lowercase());
+
+		if s.len() > 4
+			&& s.len().is_multiple_of(2)
+			&& chars.clone().tuples().all(|(l, r)| l != '.' && r == '.')
+		{
+			// Collapse acronym
+			chars.tuples().map(|(l, _)| l).collect()
+		} else {
+			chars.collect()
+		}
+	})
+}
+
+fn split_leading_article<I: Iterator<Item = String>>(iter: I) -> (Option<String>, Peekable<I>) {
+	let mut iter = iter.peekable();
+	match iter.peek().map(String::as_str) {
+		Some("a" | "an" | "the") => (iter.next(), iter),
+		_ => (None, iter),
+	}
+}
+
+/// Convert a media title to be sortable and searchable
+///
+///     use flix_model::text::make_sortable_title;
+///
+///     assert_eq!(make_sortable_title("The Matrix"), "matrix, the");
+///     assert_eq!(make_sortable_title("Marvel's Agents of S.H.I.E.L.D."), "marvels agents of shield");
+///     assert_eq!(make_sortable_title("Avatar: The Last Airbender"), "avatar the last airbender");
+///
+/// # Panics
+///
+/// Panics if `input` is not ASCII.
+pub fn make_sortable_title(title: &str) -> String {
+	let words = split_normalized_words(title);
+	let (article, words) = split_leading_article(words);
+
+	let output = Itertools::intersperse(words, " ".to_string());
+	if let Some(article) = article {
+		output.chain([", ".to_string(), article]).collect()
+	} else {
+		output.collect()
+	}
+}
+
+/// Convert a media title to a folder name representable on filesystems
+///
+///     use flix_model::text::make_fs_slug;
+///
+///     assert_eq!(make_fs_slug("The Matrix"), "matrix");
+///     assert_eq!(make_fs_slug("Marvel's Agents of S.H.I.E.L.D."), "marvels agents of shield");
+///     assert_eq!(make_fs_slug("Avatar: The Last Airbender"), "avatar the last airbender");
+///
+/// # Panics
+///
+/// Panics if `input` is not ASCII.
+pub fn make_fs_slug(title: &str) -> String {
+	let words = split_normalized_words(title);
+	let (_, words) = split_leading_article(words);
+
+	Itertools::intersperse(words, " ".to_string()).collect()
+}
+
+/// Convert a media title and year to a folder name representable on filesystems
+///
+///     use flix_model::text::make_fs_slug_year;
+///
+///     assert_eq!(make_fs_slug_year("The Matrix", 1999), "matrix (1999)");
+///     assert_eq!(make_fs_slug_year("Marvel's Agents of S.H.I.E.L.D.", 2013), "marvels agents of shield (2013)");
+///     assert_eq!(make_fs_slug_year("Avatar: The Last Airbender", 2005), "avatar the last airbender (2005)");
+///
+/// # Panics
+///
+/// Panics if `input` is not ASCII.
+pub fn make_fs_slug_year(title: &str, year: i32) -> String {
+	let words = split_normalized_words(title);
+	let (_, words) = split_leading_article(words);
+
+	Itertools::intersperse(words, " ".to_string())
+		.chain([format!(" ({year})")])
+		.collect()
+}
+
+/// Normalize a filesystem name
+///
+///     use flix_model::text::normalize_fs_name;
+///
+///     assert_eq!(normalize_fs_name("Matrix (1999)"), "matrix (1999)");
+///     assert_eq!(normalize_fs_name("Marvel's Agents of SHIELD (2013)"), "marvels agents of shield (2013)");
+///     assert_eq!(normalize_fs_name("Avatar The Last Airbender (2005)"), "avatar the last airbender (2005)");
+pub fn normalize_fs_name(input: &str) -> String {
+	let chars = input.split_ascii_whitespace().map(|s| {
+		let chars = s
+			.chars()
+			.filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '(' || *c == ')')
+			.map(|c| c.to_ascii_lowercase());
+
+		if s.len() > 4
+			&& s.len().is_multiple_of(2)
+			&& chars.clone().tuples().all(|(l, r)| l != '.' && r == '.')
+		{
+			// Collapse acronym
+			chars.tuples().map(|(l, _)| l).collect()
+		} else {
+			chars.collect()
+		}
+	});
+	Itertools::intersperse(chars, " ".to_string()).collect()
+}
+
+/// Convert a media title to a url compatible string
+///
+///     use flix_model::text::make_web_slug;
+///
+///     assert_eq!(make_web_slug("The Matrix"), "matrix");
+///     assert_eq!(make_web_slug("Marvel's Agents of S.H.I.E.L.D."), "marvels-agents-of-shield");
+///     assert_eq!(make_web_slug("Avatar: The Last Airbender"), "avatar-the-last-airbender");
+///
+/// # Panics
+///
+/// Panics if `input` is not ASCII.
+pub fn make_web_slug(title: &str) -> String {
+	let words = split_normalized_words(title);
+	let (_, words) = split_leading_article(words);
+
+	Itertools::intersperse(words, "-".to_string()).collect()
+}
+
+/// Convert a media title and year to a url compatible string
+///
+///     use flix_model::text::make_web_slug_year;
+///
+///     assert_eq!(make_web_slug_year("The Matrix", 1999), "matrix-1999");
+///     assert_eq!(make_web_slug_year("Marvel's Agents of S.H.I.E.L.D.", 2013), "marvels-agents-of-shield-2013");
+///     assert_eq!(make_web_slug_year("Avatar: The Last Airbender", 2005), "avatar-the-last-airbender-2005");
+///
+/// # Panics
+///
+/// Panics if `input` is not ASCII.
+pub fn make_web_slug_year(title: &str, year: i32) -> String {
+	let words = split_normalized_words(title);
+	let (_, words) = split_leading_article(words);
+
+	Itertools::intersperse(words, "-".to_string())
+		.chain([format!("-{year}")])
+		.collect()
+}

crates/tmdb/Cargo.toml

@@ -1,40 +1,35 @@
 [package]
 name = "flix-tmdb"
-version = "0.0.14"
+version = "0.0.16"
-
+edition.workspace = true
-categories = []
+rust-version.workspace = true
 description = "Clients and models for fetching data from TMDB"
 repository = "https://github.com/QuantumShade/flix"
-
-authors.workspace = true
-edition.workspace = true
 license-file.workspace = true
-rust-version.workspace = true
+categories = []
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints]
-workspace = true
-
-[features]
-default = []
-sea-orm = ["dep:sea-orm"]
-
 [dependencies]
-flix-model = { workspace = true }
-
 chrono = { workspace = true, features = ["serde"] }
-governor = { workspace = true, features = ["std", "jitter"] }
+flix-model = { workspace = true, features = ["serde"] }
+governor = { workspace = true, features = ["jitter", "std"] }
 nonzero_ext = { workspace = true }
-reqwest = { workspace = true, features = ["json", "rustls-tls"] }
+reqwest = { workspace = true, features = ["json", "query", "rustls"] }
+sea-orm = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 url = { workspace = true }
 url-macro = { workspace = true }
 
-sea-orm = { workspace = true, optional = true }
-
 [dev-dependencies]
 serde_test = { workspace = true }
+
+[features]
+default = []
+sea-orm = ["dep:sea-orm"]
+
+[lints]
+workspace = true

tombi.toml

@@ -0,0 +1,5 @@
+toml-version = "v1.0.0"
+
+[format.rules]
+indent-style = "tab"
+indent-width = 4