document types

backend/migrations/202510300001_rename_document_uploaded_at/down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE documents
+    RENAME COLUMN created_at TO uploaded_at;

backend/migrations/202510300001_rename_document_uploaded_at/up.sql

@@ -0,0 +1,2 @@
+ALTER TABLE documents
+    RENAME COLUMN uploaded_at TO created_at;

backend/migrations/202510300002_add_document_types/down.sql

@@ -0,0 +1,6 @@
+DROP INDEX IF EXISTS documents_document_type_idx;
+
+ALTER TABLE documents
+    DROP COLUMN IF EXISTS document_type_id;
+
+DROP TABLE IF EXISTS document_types;

backend/migrations/202510300002_add_document_types/up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE document_types (
+    id UUID PRIMARY KEY,
+    tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
+    name VARCHAR(100) NOT NULL,
+    CONSTRAINT document_types_unique_name UNIQUE (tenant_id, name)
+);
+
+ALTER TABLE documents
+    ADD COLUMN document_type_id UUID REFERENCES document_types(id) ON DELETE SET NULL;
+
+CREATE INDEX documents_document_type_idx ON documents(document_type_id);

backend/src/models.rs

@@ -248,6 +248,23 @@ pub struct Document {
     pub title: String,
     pub current_version_id: Uuid,
     pub tenant_id: Uuid,
+    pub document_type_id: Option<Uuid>,
+}
+
+#[derive(Debug, Clone, Queryable, Identifiable)]
+#[diesel(table_name = document_types)]
+pub struct DocumentType {
+    pub id: Uuid,
+    pub tenant_id: Uuid,
+    pub name: String,
+}
+
+#[derive(Debug, Insertable)]
+#[diesel(table_name = document_types)]
+pub struct NewDocumentType {
+    pub id: Uuid,
+    pub tenant_id: Uuid,
+    pub name: String,
 }
 
 #[derive(Debug, Insertable)]
@@ -263,6 +280,7 @@ pub struct NewDocument {
     pub issued_at: Option<NaiveDateTime>,
     pub title: String,
     pub tenant_id: Uuid,
+    pub document_type_id: Option<Uuid>,
 }
 
 #[derive(Debug, Clone, Queryable, Identifiable, Associations)]

backend/src/openapi.rs

@@ -48,6 +48,10 @@ use uuid::Uuid;
         doc::create_tag,
         doc::update_tag,
         doc::delete_tag,
+        doc::list_document_types,
+        doc::create_document_type,
+        doc::update_document_type,
+        doc::delete_document_type,
         doc::list_correspondents,
         doc::create_correspondent,
         doc::update_correspondent,
@@ -83,6 +87,9 @@ use uuid::Uuid;
             schemas::DocumentAssetSummary,
             schemas::DocumentAssetDetail,
             schemas::DocumentAssetObject,
+            schemas::DocumentTypeResponse,
+            schemas::CreateDocumentTypeRequest,
+            schemas::UpdateDocumentTypeRequest,
             schemas::DocumentCorrespondent,
             schemas::DocumentTag,
             schemas::UpdateDocumentRequest,
@@ -132,6 +139,7 @@ use uuid::Uuid;
         (name = "Assets", description = "Document assets"),
         (name = "Folders", description = "Folder management"),
         (name = "Tags", description = "Tag catalog"),
+        (name = "DocumentTypes", description = "Document type catalog"),
         (name = "Correspondents", description = "Correspondent catalog"),
         (name = "Profile", description = "User profile and WebDAV tokens")
     )
@@ -576,6 +584,42 @@ mod doc {
     )]
     pub(super) fn create_tag() {}
 
+    #[utoipa::path(
+        get,
+        path = "/api/document-types",
+        responses((status = 200, description = "Document types", body = [DocumentTypeResponse])),
+        tag = "DocumentTypes"
+    )]
+    pub(super) fn list_document_types() {}
+
+    #[utoipa::path(
+        post,
+        path = "/api/document-types",
+        request_body = CreateDocumentTypeRequest,
+        responses((status = 201, description = "Document type created", body = DocumentTypeResponse)),
+        tag = "DocumentTypes"
+    )]
+    pub(super) fn create_document_type() {}
+
+    #[utoipa::path(
+        patch,
+        path = "/api/document-types/{id}",
+        params(("id" = Uuid, Path, description = "Document type ID")),
+        request_body = UpdateDocumentTypeRequest,
+        responses((status = 200, description = "Document type updated", body = DocumentTypeResponse)),
+        tag = "DocumentTypes"
+    )]
+    pub(super) fn update_document_type() {}
+
+    #[utoipa::path(
+        delete,
+        path = "/api/document-types/{id}",
+        params(("id" = Uuid, Path, description = "Document type ID")),
+        responses((status = 204, description = "Document type deleted")),
+        tag = "DocumentTypes"
+    )]
+    pub(super) fn delete_document_type() {}
+
     #[utoipa::path(
         patch,
         path = "/api/tags/{id}",
@@ -773,6 +817,7 @@ pub mod schemas {
         pub query: Option<String>,
         pub tags: Option<String>,
         pub correspondents: Option<String>,
+        pub document_types: Option<String>,
         #[serde(default = "default_document_status_filter")]
         #[schema(default = "active")]
         pub status: DocumentStatusFilter,
@@ -858,6 +903,9 @@ pub mod schemas {
         pub assigned_at: String,
     }
 
+    pub use crate::routes::document_types::{CreateDocumentTypeRequest, UpdateDocumentTypeRequest};
+    pub use crate::routes::documents::DocumentTypeResponse;
+
     #[derive(Serialize, Deserialize, ToSchema)]
     pub struct DocumentResponse {
         pub id: Uuid,
@@ -875,6 +923,10 @@ pub mod schemas {
         #[schema(nullable)]
         pub issued_at: Option<String>,
         pub metadata: Value,
+        #[schema(nullable)]
+        pub document_type_id: Option<Uuid>,
+        #[schema(nullable)]
+        pub document_type: Option<DocumentTypeResponse>,
         pub tags: Vec<DocumentTag>,
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         pub correspondents: Vec<DocumentCorrespondent>,
@@ -909,6 +961,8 @@ pub mod schemas {
         pub issued_at: Option<Value>,
         #[schema(nullable)]
         pub metadata: Option<DocumentMetadataUpdate>,
+        #[schema(nullable)]
+        pub document_type_id: Option<Uuid>,
     }
 
     #[derive(Serialize, Deserialize, ToSchema)]

backend/src/routes/document_types.rs

@@ -0,0 +1,142 @@
+use axum::{
+    extract::{Json, Path},
+    http::StatusCode,
+};
+use diesel::prelude::*;
+use serde::Deserialize;
+use utoipa::ToSchema;
+use uuid::Uuid;
+
+use crate::{
+    auth::TenantScopedConn,
+    error::{AppError, AppResult},
+    models::{DocumentType, NewDocumentType},
+    schema::document_types,
+};
+
+use super::documents::DocumentTypeResponse;
+
+#[derive(Deserialize, ToSchema)]
+pub struct CreateDocumentTypeRequest {
+    pub name: String,
+}
+
+#[derive(Deserialize, ToSchema)]
+pub struct UpdateDocumentTypeRequest {
+    pub name: Option<String>,
+}
+
+pub async fn list_document_types(
+    TenantScopedConn {
+        mut conn,
+        tenant_id,
+        ..
+    }: TenantScopedConn,
+) -> AppResult<Json<Vec<DocumentTypeResponse>>> {
+    let types: Vec<DocumentType> = document_types::table
+        .filter(document_types::tenant_id.eq(tenant_id))
+        .order(document_types::name.asc())
+        .load(&mut conn)?;
+
+    Ok(Json(
+        types.into_iter().map(DocumentTypeResponse::from).collect(),
+    ))
+}
+
+pub async fn create_document_type(
+    TenantScopedConn {
+        mut conn,
+        tenant_id,
+        ..
+    }: TenantScopedConn,
+    Json(payload): Json<CreateDocumentTypeRequest>,
+) -> AppResult<(StatusCode, Json<DocumentTypeResponse>)> {
+    let name = payload.name.trim();
+    if name.is_empty() {
+        return Err(AppError::bad_request("name must not be empty"));
+    }
+
+    let new_type = NewDocumentType {
+        id: Uuid::new_v4(),
+        tenant_id,
+        name: name.to_string(),
+    };
+
+    match diesel::insert_into(document_types::table)
+        .values(&new_type)
+        .get_result::<DocumentType>(&mut conn)
+    {
+        Ok(created) => Ok((
+            StatusCode::CREATED,
+            Json(DocumentTypeResponse::from(created)),
+        )),
+        Err(diesel::result::Error::DatabaseError(
+            diesel::result::DatabaseErrorKind::UniqueViolation,
+            _,
+        )) => Err(
+            AppError::conflict("a document type with that name already exists")
+                .with_code("duplicate_document_type"),
+        ),
+        Err(err) => Err(AppError::from(err)),
+    }
+}
+
+pub async fn update_document_type(
+    Path(document_type_id): Path<Uuid>,
+    TenantScopedConn {
+        mut conn,
+        tenant_id,
+        ..
+    }: TenantScopedConn,
+    Json(payload): Json<UpdateDocumentTypeRequest>,
+) -> AppResult<Json<DocumentTypeResponse>> {
+    let name = payload
+        .name
+        .as_ref()
+        .map(|value| value.trim())
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| AppError::bad_request("name must be provided and not empty"))?;
+
+    let target = document_types::table
+        .filter(document_types::tenant_id.eq(tenant_id))
+        .find(document_type_id);
+
+    let update_result = diesel::update(target.clone())
+        .set(document_types::name.eq(name))
+        .get_result::<DocumentType>(&mut conn);
+
+    match update_result {
+        Ok(updated) => Ok(Json(DocumentTypeResponse::from(updated))),
+        Err(diesel::result::Error::NotFound) => Err(AppError::not_found()),
+        Err(diesel::result::Error::DatabaseError(
+            diesel::result::DatabaseErrorKind::UniqueViolation,
+            _,
+        )) => Err(
+            AppError::conflict("a document type with that name already exists")
+                .with_code("duplicate_document_type"),
+        ),
+        Err(err) => Err(AppError::from(err)),
+    }
+}
+
+pub async fn delete_document_type(
+    Path(document_type_id): Path<Uuid>,
+    TenantScopedConn {
+        mut conn,
+        tenant_id,
+        ..
+    }: TenantScopedConn,
+) -> AppResult<StatusCode> {
+    let affected = diesel::delete(
+        document_types::table
+            .filter(document_types::tenant_id.eq(tenant_id))
+            .find(document_type_id),
+    )
+    .execute(&mut conn)?;
+
+    if affected == 0 {
+        return Err(AppError::not_found());
+    }
+
+    Ok(StatusCode::NO_CONTENT)
+}

backend/src/routes/documents.rs

@@ -8,7 +8,7 @@ use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use chrono::{DateTime, NaiveDateTime, Utc};
 use diesel::dsl::exists;
-use diesel::{prelude::*, result::DatabaseErrorKind, select};
+use diesel::{prelude::*, result::DatabaseErrorKind, select, OptionalExtension};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
@@ -37,12 +37,13 @@ use crate::documents::{
 use crate::error::{AppError, AppResult};
 use crate::jobs::{enqueue_job, JOB_ANALYZE_DOCUMENT, JOB_INDEX_DOCUMENT_TEXT};
 use crate::models::{
-    Document, DocumentAsset, DocumentAssetObject, DocumentVersion, NewDocument, NewDocumentTag,
-    NewDocumentVersion, Tag,
+    Document, DocumentAsset, DocumentAssetObject, DocumentType, DocumentVersion, NewDocument,
+    NewDocumentTag, NewDocumentVersion, Tag,
 };
 use crate::schema::{
     document_asset_objects, document_assets, document_correspondents, document_tags,
-    document_versions, documents, folders, refresh_tokens::dsl as refresh_dsl, tags,
+    document_types, document_versions, documents, folders, refresh_tokens::dsl as refresh_dsl,
+    tags,
 };
 use crate::state::AppState;
 use crate::utils::{
@@ -65,6 +66,7 @@ pub struct DocumentListQuery {
     pub query: Option<String>,
     pub tags: Option<String>,
     pub correspondents: Option<String>,
+    pub document_types: Option<String>,
     #[serde(default = "default_document_status_filter")]
     pub status: DocumentStatusFilter,
 }
@@ -128,6 +130,21 @@ impl From<Tag> for TagResponse {
     }
 }
 
+#[derive(Clone, Serialize, Deserialize, ToSchema)]
+pub struct DocumentTypeResponse {
+    pub id: Uuid,
+    pub name: String,
+}
+
+impl From<DocumentType> for DocumentTypeResponse {
+    fn from(value: DocumentType) -> Self {
+        Self {
+            id: value.id,
+            name: value.name,
+        }
+    }
+}
+
 #[derive(Serialize, ToSchema)]
 pub struct DocumentResponse {
     pub id: Uuid,
@@ -141,6 +158,10 @@ pub struct DocumentResponse {
     pub deleted_at: Option<String>,
     pub issued_at: Option<String>,
     pub metadata: Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub document_type_id: Option<Uuid>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub document_type: Option<DocumentTypeResponse>,
     pub tags: Vec<TagResponse>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub correspondents: Vec<DocumentCorrespondentResponse>,
@@ -181,6 +202,9 @@ pub struct UpdateDocumentRequest {
     #[serde(default)]
     #[schema(nullable)]
     pub metadata: Option<DocumentMetadataUpdate>,
+    #[serde(default)]
+    #[schema(nullable, value_type = Option<Uuid>)]
+    pub document_type_id: Option<Uuid>,
 }
 
 #[derive(Serialize, ToSchema)]
@@ -234,6 +258,7 @@ struct DocumentUpdateChangeset {
     issued_at: Option<Option<NaiveDateTime>>,
     metadata: Option<Value>,
     updated_at: Option<NaiveDateTime>,
+    document_type_id: Option<Option<Uuid>>,
 }
 
 #[derive(Deserialize, Copy, Clone, PartialEq, Eq, ToSchema)]
@@ -346,6 +371,7 @@ pub async fn list_documents(
         query,
         tags,
         correspondents,
+        document_types,
         status,
     } = params;
 
@@ -378,6 +404,11 @@ pub async fn list_documents(
         .map(|s| s.trim())
         .filter(|s| !s.is_empty())
         .map(|s| s.to_owned());
+    let document_types_param = document_types
+        .as_ref()
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_owned());
 
     let include_descendants = include_descendants.unwrap_or(true);
 
@@ -517,6 +548,20 @@ pub async fn list_documents(
         }
     }
 
+    if let Some(document_types_param) = document_types_param.as_ref() {
+        let type_ids: Result<Vec<Uuid>, _> = document_types_param
+            .split(',')
+            .map(|s| Uuid::parse_str(s.trim()))
+            .collect();
+
+        if let Ok(ids) = type_ids {
+            if !ids.is_empty() {
+                let filter_values: Vec<Option<Uuid>> = ids.into_iter().map(Some).collect();
+                docs_query = docs_query.filter(documents::document_type_id.eq_any(filter_values));
+            }
+        }
+    }
+
     if let Some(ref set) = filter_ids {
         if set.is_empty() {
             return Ok(Json(vec![]));
@@ -565,6 +610,20 @@ pub async fn list_documents(
             .load(&mut conn)?
     };
 
+    let type_ids: HashSet<Uuid> = docs.iter().filter_map(|doc| doc.document_type_id).collect();
+    let doc_type_map: HashMap<Uuid, DocumentType> = if type_ids.is_empty() {
+        HashMap::new()
+    } else {
+        let ids: Vec<Uuid> = type_ids.iter().copied().collect();
+        document_types::table
+            .filter(document_types::tenant_id.eq(tenant_id))
+            .filter(document_types::id.eq_any(&ids))
+            .load::<DocumentType>(&mut conn)?
+            .into_iter()
+            .map(|typ| (typ.id, typ))
+            .collect()
+    };
+
     let doc_ids: Vec<Uuid> = docs.iter().map(|doc| doc.id).collect();
     let tags_map = load_tags_for_documents(&mut conn, &doc_ids)?;
     let mut correspondents_map = load_correspondents_for_documents(&mut conn, &doc_ids)?;
@@ -576,6 +635,9 @@ pub async fn list_documents(
         let tags = tags_map.get(&doc.id).cloned();
         let correspondents = correspondents_map.remove(&doc.id).unwrap_or_default();
         let current_version = primary_versions.get(&doc.id).cloned();
+        let doc_type = doc
+            .document_type_id
+            .and_then(|id| doc_type_map.get(&id).cloned());
         response.push(to_document_response(
             &state,
             user_id,
@@ -583,6 +645,7 @@ pub async fn list_documents(
             tags,
             correspondents,
             current_version,
+            doc_type,
         )?);
     }
 
@@ -664,6 +727,8 @@ pub async fn get_document(
         .find(doc.current_version_id)
         .first(&mut conn)?;
 
+    let doc_type = load_document_type(&mut conn, tenant_id, doc.document_type_id)?;
+
     let tags_map = load_tags_for_documents(&mut conn, &[document_id])?;
     let mut correspondents_map = load_correspondents_for_documents(&mut conn, &[document_id])?;
     let version_id = current_version.id;
@@ -680,6 +745,7 @@ pub async fn get_document(
             tags_map.get(&document_id).cloned(),
             correspondents_map.remove(&document_id).unwrap_or_default(),
             Some((version_response, assets)),
+            doc_type,
         )?,
     }))
 }
@@ -1314,6 +1380,46 @@ pub async fn update_document(
         }
     }
 
+    let doc_type_update =
+        classify_nullable(payload_obj.get("document_type_id")).map_err(AppError::bad_request)?;
+
+    match doc_type_update {
+        NullableValue::Omitted => {}
+        NullableValue::Null => {
+            if document.document_type_id.is_some() {
+                changes.document_type_id = Some(None);
+                has_changes = true;
+            }
+        }
+        NullableValue::String(raw) => {
+            let trimmed = raw.trim();
+            if trimmed.is_empty() {
+                return Err(AppError::bad_request(
+                    "document_type_id must not be empty when provided",
+                ));
+            }
+            let parsed = Uuid::parse_str(trimmed)
+                .map_err(|_| AppError::bad_request("document_type_id must be a valid UUID"))?;
+
+            if document.document_type_id != Some(parsed) {
+                let exists = document_types::table
+                    .filter(document_types::tenant_id.eq(tenant_id))
+                    .find(parsed)
+                    .first::<DocumentType>(&mut conn)
+                    .optional()?;
+
+                if exists.is_none() {
+                    return Err(AppError::bad_request(
+                        "document_type_id does not exist for this tenant",
+                    ));
+                }
+
+                changes.document_type_id = Some(Some(parsed));
+                has_changes = true;
+            }
+        }
+    }
+
     if !has_changes {
         return Err(AppError::bad_request("no changes provided"));
     }
@@ -1347,6 +1453,8 @@ pub async fn update_document(
         .find(document.current_version_id)
         .first(&mut conn)?;
 
+    let doc_type = load_document_type(&mut conn, tenant_id, document.document_type_id)?;
+
     if title_changed {
         if let Err(err) = enqueue_job(
             &mut conn,
@@ -1383,6 +1491,7 @@ pub async fn update_document(
             tags_map.get(&document_id).cloned(),
             correspondents_map.remove(&document_id).unwrap_or_default(),
             Some((version_response, assets)),
+            doc_type,
         )?,
     }))
 }
@@ -2005,6 +2114,7 @@ async fn process_upload(
                 document.updated_at = now;
             }
 
+            let doc_type = load_document_type(&mut conn, tenant_id, document.document_type_id)?;
             let tags_map = load_tags_for_documents(&mut conn, &[document.id])?;
             let mut correspondents_map =
                 load_correspondents_for_documents(&mut conn, &[document.id])?;
@@ -2028,6 +2138,7 @@ async fn process_upload(
                     tags,
                     correspondents,
                     Some((version_response, assets)),
+                    doc_type,
                 )?,
             }));
         }
@@ -2067,6 +2178,7 @@ async fn process_upload(
                 title: derived_title.clone(),
                 metadata: metadata_value.clone(),
                 tenant_id,
+                document_type_id: None,
             };
             diesel::insert_into(documents::table)
                 .values(&new_document)
@@ -2125,6 +2237,7 @@ async fn process_upload(
             )?;
         }
 
+        let doc_type = load_document_type(&mut conn, tenant_id, document.document_type_id)?;
         let tags_map = load_tags_for_documents(&mut conn, &[doc_id])?;
         let mut correspondents_map = load_correspondents_for_documents(&mut conn, &[doc_id])?;
         let tags = tags_map.get(&doc_id).cloned();
@@ -2139,6 +2252,7 @@ async fn process_upload(
                 tags,
                 correspondents,
                 Some((to_version_response(version.clone()), Vec::new())),
+                doc_type,
             )?,
         }
     };
@@ -2171,6 +2285,7 @@ pub(crate) fn to_document_response(
     tags: Option<Vec<Tag>>,
     correspondents: Vec<DocumentCorrespondentResponse>,
     current_version: Option<(DocumentVersionResponse, Vec<DocumentAssetResponse>)>,
+    doc_type: Option<DocumentType>,
 ) -> AppResult<DocumentResponse> {
     let current_version = if let Some((version, assets)) = current_version {
         let download_path = build_download_path(state, &doc, user_id)?;
@@ -2195,6 +2310,11 @@ pub(crate) fn to_document_response(
         deleted_at: doc.deleted_at.map(to_iso),
         issued_at: doc.issued_at.map(to_iso),
         metadata: doc.metadata,
+        document_type_id: doc.document_type_id,
+        document_type: doc_type.map(|typ| DocumentTypeResponse {
+            id: typ.id,
+            name: typ.name,
+        }),
         tags: tags
             .unwrap_or_default()
             .into_iter()
@@ -2204,3 +2324,19 @@ pub(crate) fn to_document_response(
         current_version,
     })
 }
+
+fn load_document_type(
+    conn: &mut PgConnection,
+    tenant_id: Uuid,
+    type_id: Option<Uuid>,
+) -> diesel::QueryResult<Option<DocumentType>> {
+    if let Some(id) = type_id {
+        document_types::table
+            .filter(document_types::tenant_id.eq(tenant_id))
+            .find(id)
+            .first::<DocumentType>(conn)
+            .optional()
+    } else {
+        Ok(None)
+    }
+}

backend/src/routes/folders.rs

@@ -1,3 +1,5 @@
+use std::collections::{HashMap, HashSet};
+
 use axum::{
     extract::{Json, Path, Query, State},
     http::StatusCode,
@@ -7,8 +9,8 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use uuid::Uuid;
 
-use crate::models::{Document, Folder, NewFolder};
-use crate::schema::{documents, folders};
+use crate::models::{Document, DocumentType, Folder, NewFolder};
+use crate::schema::{document_types, documents, folders};
 use crate::state::AppState;
 use crate::{
     auth::TenantScopedConn,
@@ -320,6 +322,20 @@ pub async fn list_folder_contents(
                 .load(&mut conn)?
         };
 
+        let type_ids: HashSet<Uuid> = docs.iter().filter_map(|doc| doc.document_type_id).collect();
+        let doc_type_map: HashMap<Uuid, DocumentType> = if type_ids.is_empty() {
+            HashMap::new()
+        } else {
+            let ids: Vec<Uuid> = type_ids.iter().copied().collect();
+            document_types::table
+                .filter(document_types::tenant_id.eq(tenant_id))
+                .filter(document_types::id.eq_any(&ids))
+                .load::<DocumentType>(&mut conn)?
+                .into_iter()
+                .map(|typ| (typ.id, typ))
+                .collect()
+        };
+
         let doc_ids: Vec<Uuid> = docs.iter().map(|doc| doc.id).collect();
         let tags_map = load_tags_for_documents(&mut conn, &doc_ids)?;
         let mut correspondents_map = load_correspondents_for_documents(&mut conn, &doc_ids)?;
@@ -332,6 +348,9 @@ pub async fn list_folder_contents(
             let tags = tags_map.get(&doc.id).cloned();
             let correspondents = correspondents_map.remove(&doc.id).unwrap_or_default();
             let current_version = primary_versions.get(&doc.id).cloned();
+            let doc_type = doc
+                .document_type_id
+                .and_then(|id| doc_type_map.get(&id).cloned());
             documents.push(to_document_response(
                 &state,
                 user_id,
@@ -339,6 +358,7 @@ pub async fn list_folder_contents(
                 tags,
                 correspondents,
                 current_version,
+                doc_type,
             )?);
         }
 

backend/src/routes/mod.rs

@@ -17,6 +17,7 @@ use crate::{auth::AuthenticatedUser, openapi::ApiDoc, state::AppState};
 
 pub mod auth;
 pub mod correspondents;
+pub mod document_types;
 pub mod documents;
 pub mod folders;
 pub mod health;
@@ -132,6 +133,17 @@ pub fn create_router(state: AppState) -> Router<()> {
         .route("/", get(tags::list_tags).post(tags::create_tag))
         .route("/:id", patch(tags::update_tag).delete(tags::delete_tag));
 
+    let document_types_routes = Router::new()
+        .route(
+            "/",
+            get(document_types::list_document_types).post(document_types::create_document_type),
+        )
+        .route(
+            "/:id",
+            patch(document_types::update_document_type)
+                .delete(document_types::delete_document_type),
+        );
+
     let correspondents_routes = Router::new()
         .route(
             "/",
@@ -159,6 +171,7 @@ pub fn create_router(state: AppState) -> Router<()> {
         .nest("/api/documents", documents_routes)
         .nest("/api/folders", folders_routes)
         .nest("/api/tags", tags_routes)
+        .nest("/api/document-types", document_types_routes)
         .nest("/api/correspondents", correspondents_routes)
         .nest("/api/profile", profile_routes)
         .nest("/api/assets", assets_routes)

backend/src/schema.rs

@@ -62,6 +62,15 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    document_types (id) {
+        id -> Uuid,
+        tenant_id -> Uuid,
+        #[max_length = 100]
+        name -> Varchar,
+    }
+}
+
 diesel::table! {
     document_versions (id) {
         id -> Uuid,
@@ -97,6 +106,7 @@ diesel::table! {
         title -> Varchar,
         current_version_id -> Uuid,
         tenant_id -> Uuid,
+        document_type_id -> Nullable<Uuid>,
     }
 }
 
@@ -250,7 +260,9 @@ diesel::joinable!(document_tags -> documents (document_id));
 diesel::joinable!(document_tags -> tags (tag_id));
 diesel::joinable!(document_tags -> tenants (tenant_id));
 diesel::joinable!(document_tags -> users (assigned_by));
+diesel::joinable!(document_types -> tenants (tenant_id));
 diesel::joinable!(document_versions -> tenants (tenant_id));
+diesel::joinable!(documents -> document_types (document_type_id));
 diesel::joinable!(documents -> folders (folder_id));
 diesel::joinable!(documents -> tenants (tenant_id));
 diesel::joinable!(folders -> tenants (tenant_id));
@@ -271,6 +283,7 @@ diesel::allow_tables_to_appear_in_same_query!(
     document_assets,
     document_correspondents,
     document_tags,
+    document_types,
     document_versions,
     documents,
     folders,

backend/tests/documents_flow.rs

@@ -23,6 +23,10 @@ struct DocumentInfo {
     deleted_at: Option<String>,
     issued_at: Option<String>,
     metadata: Value,
+    #[serde(default)]
+    document_type_id: Option<Uuid>,
+    #[serde(default)]
+    document_type: Option<DocumentTypeInfo>,
     tags: Vec<TagSummary>,
     #[serde(default)]
     correspondents: Vec<DocumentCorrespondentInfo>,
@@ -57,6 +61,10 @@ struct DocumentAssetInfo {
 struct DocumentListItem {
     id: Uuid,
     #[serde(default)]
+    document_type_id: Option<Uuid>,
+    #[serde(default)]
+    document_type: Option<DocumentTypeInfo>,
+    #[serde(default)]
     current_version: Option<DocumentVersionPayload>,
 }
 
@@ -87,6 +95,12 @@ struct DocumentCorrespondentInfo {
     name: String,
 }
 
+#[derive(Deserialize)]
+struct DocumentTypeInfo {
+    id: Uuid,
+    name: String,
+}
+
 #[derive(Deserialize)]
 struct AnalyzeJobPayload {
     document_id: Uuid,
@@ -1446,6 +1460,141 @@ async fn list_documents_by_status_filter() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn list_documents_filtered_by_document_type() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let app = TestApp::new().await?;
+
+    let password = "doctypefilter";
+    app.insert_user("doctypeuser", password, "admin").await?;
+    let token = app.login_token("doctypeuser", password).await?;
+
+    let invoices_resp = app
+        .post_json(
+            "/api/document-types",
+            &json!({"name": "Invoices"}),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(invoices_resp.status(), StatusCode::CREATED);
+    let invoices_body = body_to_vec(invoices_resp.into_body()).await?;
+    let invoices: DocumentTypeInfo = serde_json::from_slice(&invoices_body)?;
+
+    let receipts_resp = app
+        .post_json(
+            "/api/document-types",
+            &json!({"name": "Receipts"}),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(receipts_resp.status(), StatusCode::CREATED);
+    let receipts_body = body_to_vec(receipts_resp.into_body()).await?;
+    let receipts: DocumentTypeInfo = serde_json::from_slice(&receipts_body)?;
+
+    let doc_a = app
+        .upload_document(
+            "/api/documents",
+            "invoice-a.pdf",
+            "application/pdf",
+            b"invoice-a",
+            None,
+            &token,
+        )
+        .await?;
+    let doc_a_body = body_to_vec(doc_a.into_body()).await?;
+    let detail_a: DocumentDetail = serde_json::from_slice(&doc_a_body)?;
+
+    let doc_b = app
+        .upload_document(
+            "/api/documents",
+            "receipt-b.pdf",
+            "application/pdf",
+            b"receipt-b",
+            None,
+            &token,
+        )
+        .await?;
+    let doc_b_body = body_to_vec(doc_b.into_body()).await?;
+    let detail_b: DocumentDetail = serde_json::from_slice(&doc_b_body)?;
+
+    let doc_c = app
+        .upload_document(
+            "/api/documents",
+            "notes.txt",
+            "text/plain",
+            b"notes",
+            None,
+            &token,
+        )
+        .await?;
+    let doc_c_body = body_to_vec(doc_c.into_body()).await?;
+    let detail_c: DocumentDetail = serde_json::from_slice(&doc_c_body)?;
+
+    let assign_a = app
+        .patch_json(
+            &format!("/api/documents/{}", detail_a.document.id),
+            &json!({"document_type_id": invoices.id}),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(assign_a.status(), StatusCode::OK);
+
+    let assign_b = app
+        .patch_json(
+            &format!("/api/documents/{}", detail_b.document.id),
+            &json!({"document_type_id": receipts.id}),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(assign_b.status(), StatusCode::OK);
+
+    let invoices_resp = app
+        .get(
+            &format!("/api/documents?document_types={}", invoices.id),
+            Some(&token),
+        )
+        .await?;
+    assert!(invoices_resp.status().is_success());
+    let invoices_list_body = body_to_vec(invoices_resp.into_body()).await?;
+    let invoices_docs: Vec<DocumentListItem> = serde_json::from_slice(&invoices_list_body)?;
+    assert_eq!(invoices_docs.len(), 1);
+    assert_eq!(invoices_docs[0].id, detail_a.document.id);
+    assert_eq!(invoices_docs[0].document_type_id, Some(invoices.id));
+
+    let receipts_resp = app
+        .get(
+            &format!("/api/documents?document_types={}", receipts.id),
+            Some(&token),
+        )
+        .await?;
+    assert!(receipts_resp.status().is_success());
+    let receipts_list_body = body_to_vec(receipts_resp.into_body()).await?;
+    let receipts_docs: Vec<DocumentListItem> = serde_json::from_slice(&receipts_list_body)?;
+    assert_eq!(receipts_docs.len(), 1);
+    assert_eq!(receipts_docs[0].id, detail_b.document.id);
+    assert_eq!(receipts_docs[0].document_type_id, Some(receipts.id));
+
+    let combined_resp = app
+        .get(
+            &format!(
+                "/api/documents?document_types={},{}",
+                invoices.id, receipts.id
+            ),
+            Some(&token),
+        )
+        .await?;
+    assert!(combined_resp.status().is_success());
+    let combined_body = body_to_vec(combined_resp.into_body()).await?;
+    let combined_docs: Vec<DocumentListItem> = serde_json::from_slice(&combined_body)?;
+    let combined_ids: Vec<Uuid> = combined_docs.iter().map(|doc| doc.id).collect();
+    assert!(combined_ids.contains(&detail_a.document.id));
+    assert!(combined_ids.contains(&detail_b.document.id));
+    assert!(!combined_ids.contains(&detail_c.document.id));
+
+    app.cleanup().await?;
+    Ok(())
+}
+
 #[tokio::test]
 async fn restore_document_to_original_and_custom_folder() -> Result<()> {
     let _lock = acquire_db_lock().await;