Merge pull request #2354 from scpwiki/WJ-1224-text-blocks

[WJ-1224] [WJ-99] [WJ-1301] [WJ-1302] Implement hosted text blocks

Author: emmiegit

deepwell/Cargo.lock

@@ -8,7 +8,7 @@ keywords = ["wikijump", "api", "backend", "wiki"]
 categories = ["asynchronous", "database", "web-programming::http-server"]
 exclude = [".gitignore", ".editorconfig"]
 
-version = "2025.4.21"
+version = "2025.5.4"
 authors = ["Emmie Smith <[email protected]>"]
 edition = "2021"
 

deepwell/Cargo.toml

@@ -237,6 +237,10 @@ path = "../locales"
 # aggressive, but still not extremely long.
 render-timeout-ms = 2000
 
+# Similarly, this is how long that the preprocessing steps are allowed to take.
+# This value should be shorter than the render timeout.
+preprocess-timeout-ms = 500
+
 
 # Under what conditions a rerender job should be skipped rather than processed.
 #

deepwell/config.example.toml

@@ -580,6 +580,7 @@ CREATE TABLE text_block (
     page_id BIGINT NOT NULL REFERENCES page(page_id),
     block_index SMALLINT NOT NULL CHECK (block_index > 0),
     block_name TEXT CHECK (length(block_name) > 0),
+    text_type TEXT,
 
     PRIMARY KEY (block_type, page_id, block_index),
     UNIQUE (page_id, block_name)

deepwell/migrations/20220906103252_deepwell.sql

@@ -30,8 +30,8 @@ use crate::config::{Config, Secrets};
 use crate::endpoints::{
     auth::*, blob::*, category::*, domain::*, email::*, file::*, file_revision::*,
     info::*, link::*, locale::*, message::*, misc::*, page::*, page_revision::*,
-    parent::*, routing::*, site::*, site_member::*, special_error::*, text::*, user::*,
-    user_bot::*, view::*, vote::*,
+    parent::*, routing::*, site::*, site_member::*, special_error::*, text::*,
+    text_block::*, user::*, user_bot::*, view::*, vote::*,
 };
 use crate::locales::Localizations;
 use crate::services::blob::MimeAnalyzer;
@@ -223,6 +223,17 @@ async fn build_module(app_state: ServerState) -> anyhow::Result<RpcModule<Server
         "special_error_missing_custom_domain",
         special_error_missing_custom_domain,
     );
+    register!(
+        "special_error_missing_page_slug",
+        special_error_missing_page_slug,
+    );
+    register!("special_error_page_fetch", special_error_page_fetch);
+    register!(
+        "special_error_missing_file_name",
+        special_error_missing_file_name,
+    );
+    register!("special_error_file_fetch", special_error_file_fetch);
+    register!("special_error_text_block", special_error_text_block);
     register!("special_error_file_root", special_error_file_root);
 
     // Authentication
@@ -293,6 +304,9 @@ async fn build_module(app_state: ServerState) -> anyhow::Result<RpcModule<Server
     register!("parent_get_all", parent_get_all);
     register!("parent_update", parent_update);
 
+    // Hosted text blocks
+    register!("text_block_get_index", text_block_get_index);
+
     // Blob data
     register!("blob_get", blob_get);
     register!("blob_upload", blob_upload);

deepwell/src/api.rs

@@ -144,6 +144,7 @@ struct Domain {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "kebab-case")]
 struct Ftml {
+    preprocess_timeout_ms: u64,
     render_timeout_ms: u64,
     rerender_skip: Vec<RerenderSkip>,
     layout: FtmlLayout,
@@ -292,6 +293,7 @@ impl ConfigFile {
             },
             ftml:
                 Ftml {
+                    preprocess_timeout_ms,
                     render_timeout_ms,
                     rerender_skip,
                     layout:
@@ -407,6 +409,7 @@ impl ConfigFile {
             job_lift_expired_punishments: StdDuration::from_secs(
                 job_lift_expired_punishments_secs,
             ),
+            preprocess_timeout: StdDuration::from_millis(preprocess_timeout_ms),
             render_timeout: StdDuration::from_millis(render_timeout_ms),
             rerender_skip: rerender_skip
                 .iter()

deepwell/src/config/file.rs

@@ -143,7 +143,10 @@ pub struct Config {
     /// How often to run the "lift expired punishments" recurring job.
     pub job_lift_expired_punishments: StdDuration,
 
-    /// Maximum run time for a render request.
+    /// Maximum run time for the preprocessing steps of wikitext.
+    pub preprocess_timeout: StdDuration,
+
+    /// Maximum run time for parsing and rendering wikitext.
     pub render_timeout: StdDuration,
 
     /// In what circumstances a page rerender should be skipped.

deepwell/src/config/object.rs

@@ -62,6 +62,7 @@ pub mod site;
 pub mod site_member;
 pub mod special_error;
 pub mod text;
+pub mod text_block;
 pub mod user;
 pub mod user_bot;
 pub mod view;

deepwell/src/endpoints/mod.rs

@@ -52,6 +52,122 @@ pub async fn special_error_missing_custom_domain(
     SpecialErrorService::missing_custom_domain(ctx, &locales, &domain).await
 }
 
+pub async fn special_error_missing_page_slug(
+    ctx: &ServiceContext<'_>,
+    params: Params<'static>,
+) -> Result<SpecialErrorOutput> {
+    #[derive(Deserialize, Debug)]
+    struct Input {
+        locales: Vec<String>,
+        site_id: i64,
+        page_slug: String,
+    }
+
+    let Input {
+        locales,
+        site_id,
+        page_slug,
+    } = params.parse()?;
+
+    let locales = parse_locales(&locales)?;
+    SpecialErrorService::missing_page_slug(ctx, &locales, site_id, &page_slug).await
+}
+
+pub async fn special_error_page_fetch(
+    ctx: &ServiceContext<'_>,
+    params: Params<'static>,
+) -> Result<SpecialErrorOutput> {
+    #[derive(Deserialize, Debug)]
+    struct Input {
+        locales: Vec<String>,
+        site_id: i64,
+        page_slug: String,
+    }
+
+    let Input {
+        locales,
+        site_id,
+        page_slug,
+    } = params.parse()?;
+
+    let locales = parse_locales(&locales)?;
+    SpecialErrorService::page_fetch(ctx, &locales, site_id, &page_slug).await
+}
+
+pub async fn special_error_missing_file_name(
+    ctx: &ServiceContext<'_>,
+    params: Params<'static>,
+) -> Result<SpecialErrorOutput> {
+    #[derive(Deserialize, Debug)]
+    struct Input {
+        locales: Vec<String>,
+        site_id: i64,
+        page_slug: String,
+        filename: String,
+    }
+
+    let Input {
+        locales,
+        site_id,
+        page_slug,
+        filename,
+    } = params.parse()?;
+
+    let locales = parse_locales(&locales)?;
+    SpecialErrorService::missing_file_name(ctx, &locales, site_id, &page_slug, &filename)
+        .await
+}
+
+pub async fn special_error_file_fetch(
+    ctx: &ServiceContext<'_>,
+    params: Params<'static>,
+) -> Result<SpecialErrorOutput> {
+    #[derive(Deserialize, Debug)]
+    struct Input {
+        locales: Vec<String>,
+        site_id: i64,
+        page_slug: String,
+        filename: String,
+    }
+
+    let Input {
+        locales,
+        site_id,
+        page_slug,
+        filename,
+    } = params.parse()?;
+
+    let locales = parse_locales(&locales)?;
+    SpecialErrorService::file_fetch(ctx, &locales, site_id, &page_slug, &filename).await
+}
+
+pub async fn special_error_text_block(
+    ctx: &ServiceContext<'_>,
+    params: Params<'static>,
+) -> Result<SpecialErrorOutput> {
+    #[derive(Deserialize, Debug)]
+    struct Input {
+        locales: Vec<String>,
+        site_id: i64,
+        index: String,
+        block_type: String,
+        reason: String,
+    }
+
+    let Input {
+        locales,
+        site_id,
+        index,
+        block_type,
+        reason,
+    } = params.parse()?;
+
+    let locales = parse_locales(&locales)?;
+
+    SpecialErrorService::text_block(ctx, &locales, site_id, &index, &block_type, &reason)
+        .await
+}
+
 pub async fn special_error_file_root(
     ctx: &ServiceContext<'_>,
     params: Params<'static>,

deepwell/src/endpoints/special_error.rs

@@ -0,0 +1,43 @@
+/*
+ * endpoints/text.rs
+ *
+ * DEEPWELL - Wikijump API provider and database manager
+ * Copyright (C) 2019-2025 Wikijump Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+use super::prelude::*;
+use crate::models::sea_orm_active_enums::TextBlockType;
+use crate::services::text_block::TextBlockIndex;
+
+#[derive(Deserialize, Debug, Clone)]
+struct GetIndexInput {
+    page_id: i64,
+    block_type: TextBlockType,
+    name: String,
+}
+
+pub async fn text_block_get_index(
+    ctx: &ServiceContext<'_>,
+    params: Params<'static>,
+) -> Result<Option<TextBlockIndex>> {
+    let GetIndexInput {
+        page_id,
+        block_type,
+        name,
+    } = params.parse()?;
+
+    TextBlockService::get_block_index(ctx, page_id, block_type, &name).await
+}