feat: Enhance CI workflows and service management features

- Added steps to build the `temps-captcha-wasm` crate in CI workflows, ensuring WebAssembly components are built during releases.
- Integrated Bun installation in CI workflows to streamline JavaScript dependency management.
- Updated `ParameterStrategy` implementations for Postgres, Redis, and MongoDB to include new updateable keys, enhancing service configuration flexibility.
- Introduced methods to verify Docker images are pullable before upgrades in MongoDB, Redis, and S3 services, improving reliability during service updates.
- Refactored sidebar components in the web application to improve responsiveness and user experience across different screen sizes.

Author: dviejokfs

.github/workflows/release.yml

@@ -61,6 +61,11 @@ jobs:
           cd web
           bun install
 
+      - name: Build WASM
+        run: |
+          cd crates/temps-captcha-wasm
+          bun run build
+
       - name: Build release binary
         run: cargo build --release --bin temps
         env:
@@ -138,6 +143,11 @@ jobs:
           cd web
           bun install
 
+      - name: Build WASM
+        run: |
+          cd crates/temps-captcha-wasm
+          bun run build
+
       - name: Build release binary
         run: cargo build --release --bin temps --target x86_64-apple-darwin
         env:
@@ -215,6 +225,11 @@ jobs:
           cd web
           bun install
 
+      - name: Build WASM
+        run: |
+          cd crates/temps-captcha-wasm
+          bun run build
+
       - name: Build release binary
         run: cargo build --release --bin temps --target aarch64-apple-darwin
         env:

.github/workflows/rust-tests.yml

@@ -25,9 +25,19 @@ jobs:
       - name: Install wasm-pack
         run: curl https://rustwasm.org/wasm-pack/installer/init.sh -sSf | sh
 
+      - name: Install Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2
 
+      - name: Build WASM
+        run: |
+          cd crates/temps-captcha-wasm
+          bun run build
+
       - name: Check workspace
         run: cargo check --workspace --all-targets
 
@@ -61,9 +71,19 @@ jobs:
       - name: Install wasm-pack
         run: curl https://rustwasm.org/wasm-pack/installer/init.sh -sSf | sh
 
+      - name: Install Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2
 
+      - name: Build WASM
+        run: |
+          cd crates/temps-captcha-wasm
+          bun run build
+
       - name: Run clippy
         run: cargo clippy --workspace --all-targets --all-features -- -D warnings
 
@@ -112,9 +132,19 @@ jobs:
       - name: Install wasm-pack
         run: curl https://rustwasm.org/wasm-pack/installer/init.sh -sSf | sh
 
+      - name: Install Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2
 
+      - name: Build WASM
+        run: |
+          cd crates/temps-captcha-wasm
+          bun run build
+
       - name: Verify TimescaleDB is ready
         run: |
           echo "Checking if TimescaleDB port is open..."

crates/temps-providers/src/externalsvc/mongodb.rs

@@ -3,7 +3,7 @@ use async_trait::async_trait;
 use bollard::exec::CreateExecOptions;
 use bollard::query_parameters::{InspectContainerOptions, StopContainerOptions};
 use bollard::{body_full, Docker};
-use futures::StreamExt;
+use futures::{StreamExt, TryStreamExt};
 use mongodb::bson::doc;
 use mongodb::options::ClientOptions;
 use mongodb::Client as MongoClient;
@@ -417,6 +417,49 @@ impl MongodbService {
 
         Ok(databases)
     }
+
+    /// Verify that a Docker image can be pulled without actually downloading the full image
+    /// Attempts to pull the image - fails if it doesn't exist or cannot be accessed
+    #[allow(dead_code)]
+    async fn verify_image_pullable(&self, image: &str) -> Result<()> {
+        // Parse image name and tag
+        let (image_name, tag) = if let Some((name, tag)) = image.split_once(':') {
+            (name.to_string(), tag.to_string())
+        } else {
+            (image.to_string(), "latest".to_string())
+        };
+
+        info!("Attempting to pull Docker image: {}", image);
+
+        // Try to pull the image - this will fail if it doesn't exist
+        let result = self
+            .docker
+            .create_image(
+                Some(bollard::query_parameters::CreateImageOptions {
+                    from_image: Some(image_name.clone()),
+                    tag: Some(tag.clone()),
+                    ..Default::default()
+                }),
+                None,
+                None,
+            )
+            .try_collect::<Vec<_>>()
+            .await;
+
+        match result {
+            Ok(_) => {
+                info!("Docker image {} is available and pullable", image);
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to pull Docker image {}: {}", image, e);
+                Err(anyhow::anyhow!(
+                    "Cannot upgrade: Docker image '{}' is not available or cannot be pulled. Error: {}",
+                    image, e
+                ))
+            }
+        }
+    }
 }
 
 #[async_trait]
@@ -507,7 +550,7 @@ impl ExternalService for MongodbService {
                     "port" => true,      // Port can be changed
                     "database" => false, // Don't change database name after creation
                     "username" => false, // Don't change username after creation
-                    "password" => true,  // Password can be updated
+                    "password" => false, // Password is auto-generated and cannot be changed
                     "image" => true,     // Image can be upgraded
                     "version" => true,   // Version can be upgraded
                     _ => false,
@@ -1080,6 +1123,34 @@ impl ExternalService for MongodbService {
         let (_, version) = self.get_current_docker_image().await?;
         Ok(version)
     }
+
+    async fn upgrade(&self, old_config: ServiceConfig, new_config: ServiceConfig) -> Result<()> {
+        info!("Starting MongoDB upgrade");
+
+        let _old_mongodb_config = self.get_mongodb_config(old_config)?;
+        let new_mongodb_config = self.get_mongodb_config(new_config)?;
+
+        // Verify the new image can be pulled BEFORE stopping the old container
+        let new_image = format!(
+            "{}:{}",
+            new_mongodb_config.image, new_mongodb_config.version
+        );
+        info!("Verifying new Docker image is available: {}", new_image);
+        self.verify_image_pullable(&new_image).await?;
+        info!("New Docker image verified and is available");
+
+        // Stop the old container
+        info!("Stopping old MongoDB container");
+        self.stop().await?;
+
+        // Create container with new image (keeping the same volume for data persistence)
+        info!("Starting MongoDB container with new image");
+        self.create_container(&self.docker, &new_mongodb_config)
+            .await?;
+
+        info!("MongoDB upgrade completed successfully");
+        Ok(())
+    }
 }
 
 #[cfg(test)]

crates/temps-providers/src/externalsvc/postgres.rs

@@ -382,6 +382,11 @@ impl PostgresService {
             exposed_ports: Some(HashMap::from([("5432/tcp".to_string(), HashMap::new())])),
             env: Some(env_vars.iter().map(|s| s.to_string()).collect()),
             labels: Some(container_labels),
+            cmd: Some(vec![
+                "postgres".to_string(),
+                "-c".to_string(),
+                format!("max_connections={}", config.max_connections),
+            ]),
             host_config: Some(bollard::models::HostConfig {
                 restart_policy: Some(bollard::models::RestartPolicy {
                     name: Some(bollard::models::RestartPolicyNameEnum::ALWAYS),
@@ -765,6 +770,11 @@ impl PostgresService {
                 format!("POSTGRES_USER=postgres"),
                 format!("POSTGRES_PASSWORD={}", new_config.password),
             ]),
+            cmd: Some(vec![
+                "postgres".to_string(),
+                "-c".to_string(),
+                format!("max_connections={}", new_config.max_connections),
+            ]),
             host_config: Some(bollard::models::HostConfig {
                 mounts: Some(vec![bollard::models::Mount {
                     target: Some("/var/lib/postgresql/data".to_string()),
@@ -901,6 +911,48 @@ impl PostgresService {
 
         Ok(())
     }
+
+    /// Verify that a Docker image can be pulled without actually downloading the full image
+    /// Attempts to pull the image - fails if it doesn't exist or cannot be accessed
+    async fn verify_image_pullable(&self, image: &str) -> Result<()> {
+        // Parse image name and tag
+        let (image_name, tag) = if let Some((name, tag)) = image.split_once(':') {
+            (name.to_string(), tag.to_string())
+        } else {
+            (image.to_string(), "latest".to_string())
+        };
+
+        info!("Attempting to pull Docker image: {}", image);
+
+        // Try to pull the image - this will fail if it doesn't exist
+        let result = self
+            .docker
+            .create_image(
+                Some(bollard::query_parameters::CreateImageOptions {
+                    from_image: Some(image_name.clone()),
+                    tag: Some(tag.clone()),
+                    ..Default::default()
+                }),
+                None,
+                None,
+            )
+            .try_collect::<Vec<_>>()
+            .await;
+
+        match result {
+            Ok(_) => {
+                info!("Docker image {} is available and pullable", image);
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to pull Docker image {}: {}", image, e);
+                Err(anyhow::anyhow!(
+                    "Cannot upgrade: Docker image '{}' is not available or cannot be pulled. Error: {}",
+                    image, e
+                ))
+            }
+        }
+    }
 }
 
 #[async_trait]
@@ -1212,7 +1264,7 @@ impl ExternalService for PostgresService {
                     "port" => true,            // Port can be changed
                     "database" => false,       // Don't change database name after creation
                     "username" => false,       // Don't change username after creation
-                    "password" => true,        // Password can be updated
+                    "password" => false,       // Password is auto-generated and cannot be changed
                     "max_connections" => true, // Max connections can be adjusted
                     "ssl_mode" => true,        // SSL mode can be changed
                     "docker_image" => true,    // Docker image can be upgraded
@@ -1484,6 +1536,15 @@ impl ExternalService for PostgresService {
             ));
         }
 
+        // Verify the new image can be pulled BEFORE stopping the old container
+        info!(
+            "Verifying new Docker image is available: {}",
+            new_pg_config.docker_image
+        );
+        self.verify_image_pullable(&new_pg_config.docker_image)
+            .await?;
+        info!("New Docker image verified and is available");
+
         // Stop the old container
         info!("Stopping old PostgreSQL container");
         self.stop().await?;

crates/temps-providers/src/externalsvc/redis.rs

@@ -428,6 +428,49 @@ impl RedisService {
 
         Ok(RedisConfig::from(input_config))
     }
+
+    /// Verify that a Docker image can be pulled without actually downloading the full image
+    /// Attempts to pull the image - fails if it doesn't exist or cannot be accessed
+    #[allow(dead_code)]
+    async fn verify_image_pullable(&self, image: &str) -> Result<()> {
+        // Parse image name and tag
+        let (image_name, tag) = if let Some((name, tag)) = image.split_once(':') {
+            (name.to_string(), tag.to_string())
+        } else {
+            (image.to_string(), "latest".to_string())
+        };
+
+        info!("Attempting to pull Docker image: {}", image);
+
+        // Try to pull the image - this will fail if it doesn't exist
+        let result = self
+            .docker
+            .create_image(
+                Some(bollard::query_parameters::CreateImageOptions {
+                    from_image: Some(image_name.clone()),
+                    tag: Some(tag.clone()),
+                    ..Default::default()
+                }),
+                None,
+                None,
+            )
+            .try_collect::<Vec<_>>()
+            .await;
+
+        match result {
+            Ok(_) => {
+                info!("Docker image {} is available and pullable", image);
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to pull Docker image {}: {}", image, e);
+                Err(anyhow::anyhow!(
+                    "Cannot upgrade: Docker image '{}' is not available or cannot be pulled. Error: {}",
+                    image, e
+                ))
+            }
+        }
+    }
 }
 
 #[async_trait]
@@ -540,11 +583,11 @@ impl ExternalService for RedisService {
             for key in properties.keys().cloned().collect::<Vec<_>>() {
                 // Define which fields should be editable
                 let editable = match key.as_str() {
-                    "host" => false,    // Don't change host after creation
-                    "port" => true,     // Port can be changed
-                    "password" => true, // Password can be updated
-                    "image" => true,    // Image can be upgraded
-                    "version" => true,  // Version can be changed
+                    "host" => false,     // Don't change host after creation
+                    "port" => true,      // Port can be changed
+                    "password" => false, // Password is auto-generated and cannot be changed
+                    "image" => true,     // Image can be upgraded
+                    "version" => true,   // Version can be changed
                     _ => false,
                 };
 
@@ -1051,6 +1094,31 @@ impl ExternalService for RedisService {
         let (_, version) = self.get_current_docker_image().await?;
         Ok(version)
     }
+
+    async fn upgrade(&self, old_config: ServiceConfig, new_config: ServiceConfig) -> Result<()> {
+        info!("Starting Redis upgrade");
+
+        let _old_redis_config = self.get_redis_config(old_config)?;
+        let new_redis_config = self.get_redis_config(new_config)?;
+
+        // Verify the new image can be pulled BEFORE stopping the old container
+        let new_image = format!("{}:{}", new_redis_config.image, new_redis_config.version);
+        info!("Verifying new Docker image is available: {}", new_image);
+        self.verify_image_pullable(&new_image).await?;
+        info!("New Docker image verified and is available");
+
+        // Stop the old container
+        info!("Stopping old Redis container");
+        self.stop().await?;
+
+        // Create container with new image (keeping the same volume for data persistence)
+        info!("Starting Redis container with new image");
+        self.create_container(&self.docker, &new_redis_config, &new_redis_config.password)
+            .await?;
+
+        info!("Redis upgrade completed successfully");
+        Ok(())
+    }
 }
 
 #[cfg(test)]