chore: release 1.11.1

* fix: s3 port type mismatch, add string_or_number_to_string deserializer

* chore: docker-compose.databases.yml

* fix: tests and refactoring, add justfile instead of makefile

* fix: databases.json

* fix: add gbak in production Dockerfile

---------

Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>

.gitignore

@@ -3,4 +3,7 @@
 /src/data/
 
 .DS_Store
-.env
+.env
+
+.claude
+/docs

CITATION.cff

@@ -27,5 +27,5 @@ keywords:
   - self-hosted
   - portabase
 license: Apache-2.0
-version: 1.10.1
+version: 1.11.1
 date-released: '2026-02-24'

Cargo.lock

@@ -169,6 +169,19 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "asynchronous-codec"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057f2c32adbb2fc158e22fb38433c8e9bbf76b75a4732c7c0cbaf695fb65568"
+dependencies = [
+ "bytes",
+ "futures-sink",
+ "futures-util",
+ "memchr",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -496,7 +509,7 @@ dependencies = [
  "pin-project-lite",
  "rustls 0.21.12",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -770,7 +783,7 @@ dependencies = [
  "pin-project-lite",
  "rand 0.9.2",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "serde",
  "serde_derive",
@@ -968,6 +981,12 @@ version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
 
+[[package]]
+name = "connection-string"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "510ca239cf13b7f8d16a2b48f263de7b4f8c566f0af58d901031473c76afb1e3"
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -1436,6 +1455,26 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -2050,7 +2089,7 @@ dependencies = [
  "hyper 1.8.1",
  "hyper-util",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -2854,6 +2893,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
 [[package]]
 name = "openssl-probe"
 version = "0.2.1"
@@ -3038,7 +3083,7 @@ dependencies = [
 
 [[package]]
 name = "portabase-agent"
-version = "1.10.1"
+version = "1.11.1"
 dependencies = [
  "aes",
  "aes-gcm",
@@ -3076,6 +3121,7 @@ dependencies = [
  "testcontainers",
  "testcontainers-modules",
  "thiserror 2.0.18",
+ "tiberius",
  "time",
  "tokio",
  "tokio-postgres",
@@ -3191,6 +3237,12 @@ dependencies = [
  "termtree",
 ]
 
+[[package]]
+name = "pretty-hex"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fa0831dd7cc608c38a5e323422a0077678fa5744aa2be4ad91c4ece8eec8d5"
+
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -3677,16 +3729,37 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe 0.1.6",
+ "rustls-pemfile",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
 [[package]]
 name = "rustls-native-certs"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "openssl-probe",
+ "openssl-probe 0.2.1",
  "rustls-pki-types",
  "schannel",
- "security-framework",
+ "security-framework 3.7.0",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
 ]
 
 [[package]]
@@ -3711,10 +3784,10 @@ dependencies = [
  "log",
  "once_cell",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-platform-verifier-android",
  "rustls-webpki 0.103.9",
- "security-framework",
+ "security-framework 3.7.0",
  "security-framework-sys",
  "webpki-root-certs",
  "windows-sys 0.61.2",
@@ -3832,6 +3905,19 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
 [[package]]
 name = "security-framework"
 version = "3.7.0"
@@ -4353,6 +4439,34 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "tiberius"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1446cb4198848d1562301a3340424b4f425ef79f35ef9ee034769a9dd92c10d"
+dependencies = [
+ "async-trait",
+ "asynchronous-codec",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "connection-string",
+ "encoding_rs",
+ "enumflags2",
+ "futures-util",
+ "num-traits",
+ "once_cell",
+ "pin-project-lite",
+ "pretty-hex",
+ "rustls-native-certs 0.6.3",
+ "rustls-pemfile",
+ "thiserror 1.0.69",
+ "tokio-rustls 0.24.1",
+ "tokio-util",
+ "tracing",
+ "uuid",
+]
+
 [[package]]
 name = "time"
 version = "0.3.47"
@@ -4668,6 +4782,7 @@ version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
+ "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.10.1"
+version = "1.11.1"
 edition = "2024"
 
 [dependencies]
@@ -35,7 +35,8 @@ rand = "0.9.2"
 bytes = "1.11.0"
 async-stream = "0.3.6"
 uuid = { version = "1.20.0", features = ["v4"] }
-tokio-util = "0.7.18"
+tokio-util = { version = "0.7.18", features = ["compat"] }
+tiberius = { version = "0.12", default-features = false, features = ["rustls", "chrono"] }
 aws-config = "1.8.13"
 aws-sdk-s3 = { version = "1.122.0", features = ["behavior-version-latest"] }
 async-compression = { version = "0.4.37", features = ["tokio", "gzip"] }

databases.json

@@ -101,6 +101,16 @@
       "port": 3050,
       "host": "db-firebird",
       "generated_id": "16706124-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 13 - MsSQL",
+      "database": "myappdb",
+      "type": "mssql",
+      "username": "sa",
+      "password": "Portabase!Strong1",
+      "port": 1433,
+      "host": "db-mssql",
+      "generated_id": "16706125-ff7e-4c97-8c83-0adeff214682"
     }
   ]
 }

databases.toml

@@ -100,4 +100,14 @@ port = 3050
 host = "db-firebird"
 generated_id = "16706124-ff7e-4c97-8c83-0adeff214681"
 
+[[databases]]
+name = "Test database 13 - MSSQL"
+database = "myappdb"
+type = "mssql"
+username = "sa"
+password = "Portabase!Strong1"
+port = 1433
+host = "db-mssql"
+generated_id = "16706125-ff7e-4c97-8c83-0adeff214682"
+
 

docker-compose.databases.yml

@@ -159,6 +159,24 @@ services:
     networks:
       - portabase
 
+  db-mssql:
+    container_name: db-mssql
+    image: mcr.microsoft.com/azure-sql-edge:latest
+    ports:
+      - "1433:1433"
+    environment:
+      ACCEPT_EULA: "Y"
+      MSSQL_SA_PASSWORD: "Portabase!Strong1"
+    volumes:
+      - mssql-data:/var/opt/mssql
+    networks:
+      - portabase
+    healthcheck:
+      test: ["CMD-SHELL", "cat /proc/net/tcp6 | grep -q '059901' || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 20
+
 volumes:
   postgres-data:
   mariadb-data:
@@ -171,6 +189,7 @@ volumes:
   valkey-data:
   valkey-data-auth:
   firebird-data:
+  mssql-data:
 
 networks:
   portabase:

docker-compose.yml

@@ -19,7 +19,7 @@ services:
       APP_ENV: development
       LOG: debug
       TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiOTFlYmY4MmYtY2I4OC00N2M3LWE5MWUtMDUyMmU2NzNjZjE4IiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNzNlZmJhNjMtNTkzMy00Mzk3LWI0ZmMtMjlmNTViNmI5YzA4IiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
       #CHUNK_SIZE_MB: "1"
       #POOLING: 1
       #DATABASES_CONFIG_FILE: "config.toml"

docker/Dockerfile

@@ -22,6 +22,20 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
+ENV DOTNET_ROOT=/usr/local/dotnet
+RUN curl -sSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh \
+    && chmod +x /tmp/dotnet-install.sh \
+    && /tmp/dotnet-install.sh --channel 8.0 --install-dir /usr/local/dotnet \
+    && rm /tmp/dotnet-install.sh \
+    && /usr/local/dotnet/dotnet tool install --global microsoft.sqlpackage
+
+ENV PATH="$PATH:/usr/local/dotnet:/root/.dotnet/tools"
+
+RUN ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/') \
+    && curl -sSL "https://github.com/microsoft/go-sqlcmd/releases/latest/download/sqlcmd-linux-${ARCH}.tar.bz2" \
+       | tar -xjf - -C /usr/local/bin sqlcmd \
+    && chmod +x /usr/local/bin/sqlcmd
+
 ARG TARGETARCH
 
 # =========================
@@ -97,12 +111,19 @@ RUN apt-get update && apt-get install -y \
     libreadline8 \
     libncurses6 \
     zlib1g \
+    curl \
     mariadb-client \
     sqlite3 \
     redis-tools \
     valkey \
+    firebird3.0-utils \
     && rm -rf /var/lib/apt/lists/*
 
+ENV DOTNET_ROOT=/usr/local/dotnet
+RUN curl -sSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh \
+    && chmod +x /tmp/dotnet-install.sh \
+    && /tmp/dotnet-install.sh --channel 8.0 --runtime dotnet --install-dir /usr/local/dotnet \
+    && rm /tmp/dotnet-install.sh
 
 WORKDIR /app
 
@@ -113,8 +134,9 @@ RUN chmod +x /entrypoint.sh
 
 COPY --from=base /usr/lib/postgresql/ /usr/lib/postgresql/
 COPY --from=base /usr/local/mongodb/bin/ /usr/local/mongodb/bin/
+COPY --from=base /root/.dotnet/tools/ /root/.dotnet/tools/
 
-
+ENV PATH="$PATH:/usr/local/dotnet:/root/.dotnet/tools"
 ENV APP_ENV=production
 
 CMD ["/entrypoint.sh"]

justfile

@@ -45,6 +45,11 @@ seed-firebird:
     echo "SELECT RDB\$RELATION_NAME FROM RDB\$RELATIONS WHERE RDB\$SYSTEM_FLAG = 0 AND RDB\$VIEW_BLR IS NULL;" \
     | docker exec -i db-firebird isql -user alice -password fake_password /var/lib/firebird/data/mirror.fdb
 
+seed-mssql:
+    echo "Seeding MSSQL..."
+    docker exec -i rust-dev sqlcmd -S "db-mssql,1433" -U sa -P "$MSSQL_SA_PASSWORD" -N disable -i /app/scripts/mssql/seed.sql
+    echo "Done"
+
 seed-all:
     just seed-mongo
     just seed-mysql
@@ -52,4 +57,5 @@ seed-all:
     just seed-postgres-1gb
     just seed-sqlite
     just seed-mongo
-    just seed-firebird
+    just seed-firebird
+    just seed-mssql

scripts/mssql/seed.sql

@@ -0,0 +1,20 @@
+IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = N'myappdb')
+    CREATE DATABASE [myappdb];
+GO
+
+USE [myappdb];
+GO
+
+IF OBJECT_ID('users', 'U') IS NULL
+    CREATE TABLE users (
+        id       INT IDENTITY(1,1) PRIMARY KEY,
+        email    NVARCHAR(255) NOT NULL UNIQUE,
+        name     NVARCHAR(255),
+        created_at DATETIME DEFAULT GETDATE()
+    );
+GO
+
+INSERT INTO users (email, name) VALUES ('alice@example.com', 'Alice');
+INSERT INTO users (email, name) VALUES ('bob@example.com',   'Bob');
+INSERT INTO users (email, name) VALUES ('charlie@example.com', 'Charlie');
+GO

src/domain/factory.rs

@@ -11,6 +11,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use crate::domain::firebird::database::FirebirdDatabase;
 use crate::domain::mariadb::database::MariaDBDatabase;
+use crate::domain::mssql::database::MssqlDatabase;
 
 #[async_trait::async_trait]
 pub trait Database: Send + Sync {
@@ -36,6 +37,7 @@ impl DatabaseFactory {
             DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
             DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
             DbType::Firebird => Arc::new(FirebirdDatabase::new(cfg)),
+            DbType::Mssql => Arc::new(MssqlDatabase::new(cfg)),
         }
     }
 
@@ -52,6 +54,7 @@ impl DatabaseFactory {
             DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
             DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
             DbType::Firebird => Arc::new(FirebirdDatabase::new(cfg)),
+            DbType::Mssql => Arc::new(MssqlDatabase::new(cfg)),
         }
     }
 }

src/domain/mod.rs

@@ -7,3 +7,4 @@ mod sqlite;
 mod valkey;
 mod mariadb;
 mod firebird;
+pub mod mssql;

src/domain/mssql/backup.rs

@@ -0,0 +1,47 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting MSSQL backup for database {}", cfg.name);
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+        let connection_string = format!(
+            "Server=tcp:{},{};Database={};User Id={};Password={};TrustServerCertificate=True;Encrypt=False",
+            cfg.host, cfg.port, cfg.database, cfg.username, cfg.password
+        );
+
+        info!(
+            "MSSQL backup: {}:{}/{} → {}",
+            cfg.host,
+            cfg.port,
+            cfg.database,
+            file_path.display()
+        );
+
+        let output = Command::new("sqlpackage")
+            .arg("/a:Export")
+            .arg(format!("/scs:{}", connection_string))
+            .arg(format!("/tf:{}", file_path.display()))
+            .output()
+            .with_context(|| format!("Failed to run sqlpackage for {}", cfg.name))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            error!("MSSQL backup failed — stderr: {} stdout: {}", stderr, stdout);
+            anyhow::bail!("MSSQL backup failed for {}: {}", cfg.name, stderr);
+        }
+
+        info!("MSSQL backup completed: {}", file_path.display());
+        Ok(file_path)
+    })
+    .await?
+}

src/domain/mssql/connection.rs

@@ -0,0 +1,18 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::Result;
+use tiberius::{AuthMethod, Client, Config};
+use tokio::net::TcpStream;
+use tokio_util::compat::{Compat, TokioAsyncWriteCompatExt};
+
+pub async fn build_client(cfg: &DatabaseConfig) -> Result<Client<Compat<TcpStream>>> {
+    let mut config = Config::new();
+    config.host(&cfg.host);
+    config.port(cfg.port);
+    config.authentication(AuthMethod::sql_server(&cfg.username, &cfg.password));
+    config.trust_cert();
+
+    let tcp = TcpStream::connect(config.get_addr()).await?;
+    tcp.set_nodelay(true)?;
+    let client = Client::connect(config, tcp.compat_write()).await?;
+    Ok(client)
+}

src/domain/mssql/database.rs

@@ -0,0 +1,47 @@
+use super::{backup, ping, restore};
+use crate::domain::factory::Database;
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+use anyhow::Result;
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+
+pub struct MssqlDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl MssqlDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for MssqlDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".bacpac"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        let res = backup::run(
+            self.cfg.clone(),
+            dir.to_path_buf(),
+            self.file_extension(),
+        )
+        .await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, file: &Path) -> Result<()> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+}

src/domain/mssql/mod.rs

@@ -0,0 +1,5 @@
+pub mod database;
+mod connection;
+mod ping;
+mod backup;
+mod restore;

src/domain/mssql/ping.rs

@@ -0,0 +1,24 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::Result;
+use tracing::{error, info};
+
+pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
+    info!("Running ping for MSSQL database {}", cfg.name);
+
+    match super::connection::build_client(&cfg).await {
+        Ok(mut client) => match client.simple_query("SELECT 1").await {
+            Ok(_) => {
+                info!("MSSQL ping succeeded for {}", cfg.name);
+                Ok(true)
+            }
+            Err(e) => {
+                error!("MSSQL ping query failed for {}: {:?}", cfg.name, e);
+                Ok(false)
+            }
+        },
+        Err(e) => {
+            error!("MSSQL connection failed for {}: {:?}", cfg.name, e);
+            Ok(false)
+        }
+    }
+}

src/domain/mssql/restore.rs

@@ -0,0 +1,45 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        debug!("Starting MSSQL restore for database {}", cfg.name);
+
+        let connection_string = format!(
+            "Server=tcp:{},{};Database={};User Id={};Password={};TrustServerCertificate=True;Encrypt=False",
+            cfg.host, cfg.port, cfg.database, cfg.username, cfg.password
+        );
+
+        info!(
+            "MSSQL restore: {} → {}:{}/{}",
+            restore_file.display(),
+            cfg.host,
+            cfg.port,
+            cfg.database
+        );
+
+        let output = Command::new("sqlpackage")
+            .arg("/a:Import")
+            .arg(format!("/tcs:{}", connection_string))
+            .arg(format!("/sf:{}", restore_file.display()))
+            .output()
+            .with_context(|| format!("Failed to run sqlpackage restore for {}", cfg.name))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            error!(
+                "MSSQL restore failed for {} — stderr: {} stdout: {}",
+                cfg.name, stderr, stdout
+            );
+            anyhow::bail!("MSSQL restore failed for {}: {}", cfg.name, stderr);
+        }
+
+        info!("MSSQL restore completed for {}", cfg.name);
+        Ok(())
+    })
+    .await?
+}

src/services/backup/runner.rs

@@ -52,13 +52,16 @@ impl BackupService {
                 code: Some("backup_already_in_progress".into()),
             }),
 
-            Err(_) => Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "failed".into(),
-                backup_file: None,
-                code: None,
-            }),
+            Err(e) => {
+                error!("Backup failed for {}: {:?}", generated_id, e);
+                Ok(BackupResult {
+                    generated_id,
+                    db_type,
+                    status: "failed".into(),
+                    backup_file: None,
+                    code: None,
+                })
+            }
         }
     }
 }

src/services/config.rs

@@ -21,7 +21,8 @@ pub enum DbType {
     Sqlite,
     Redis,
     Valkey,
-    Firebird
+    Firebird,
+    Mssql,
 }
 
 impl DbType {
@@ -35,6 +36,7 @@ impl DbType {
             DbType::Redis => "redis",
             DbType::Valkey => "valkey",
             DbType::Firebird => "firebird",
+            DbType::Mssql => "mssql",
         }
     }
 }
@@ -165,14 +167,14 @@ impl ConfigService {
             }
 
             let username = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::Mssql => {
                     required(&db.username, &db.name, "username")?
                 }
                 _ => optional(&db.username),
             };
 
             let password = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::Mssql => {
                     required(&db.password, &db.name, "password")?
                 }
                 _ => optional(&db.password),
@@ -185,7 +187,8 @@ impl ConfigService {
                 | DbType::MongoDB
                 | DbType::Redis
                 | DbType::Firebird
-                | DbType::Valkey => required(&db.host, &db.name, "host")?,
+                | DbType::Valkey
+                | DbType::Mssql => required(&db.host, &db.name, "host")?,
                 DbType::Sqlite => optional(&db.host),
             };
 
@@ -196,7 +199,8 @@ impl ConfigService {
                 | DbType::MongoDB
                 | DbType::Redis
                 | DbType::Firebird
-                | DbType::Valkey => required(&db.port, &db.name, "port")?,
+                | DbType::Valkey
+                | DbType::Mssql => required(&db.port, &db.name, "port")?,
                 DbType::Sqlite => db.port.unwrap_or(0),
             };
 

src/tests/domain/mod.rs

@@ -5,3 +5,4 @@ mod postgres;
 mod redis;
 mod valkey;
 mod firebird;
+mod mssql;

src/tests/domain/mssql.rs

@@ -0,0 +1,151 @@
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::{DatabaseConfig, DbType};
+use crate::tests::init_tracing_for_test;
+use crate::utils::compress::{compress_to_tar_gz_large, decompress_large_tar_gz};
+use std::path::PathBuf;
+use std::time::Duration;
+use tempfile::TempDir;
+use tiberius::{AuthMethod, Client, Config};
+use testcontainers::runners::AsyncRunner;
+use testcontainers::{ContainerAsync, GenericImage, ImageExt};
+use testcontainers::core::IntoContainerPort;
+use tokio::net::TcpStream;
+use tokio_util::compat::TokioAsyncWriteCompatExt;
+use tracing::{error, info};
+
+const SA_PASSWORD: &str = "Test!Str0ng1";
+
+async fn start_container() -> ContainerAsync<GenericImage> {
+    GenericImage::new("mcr.microsoft.com/azure-sql-edge", "latest")
+        .with_exposed_port(1433.tcp())
+        .with_env_var("ACCEPT_EULA", "Y")
+        .with_env_var("MSSQL_SA_PASSWORD", SA_PASSWORD)
+        .start()
+        .await
+        .expect("azure-sql-edge container started")
+}
+
+async fn create_user_database(host: &str, port: u16, db_name: &str) {
+    let mut config = Config::new();
+    config.host(host);
+    config.port(port);
+    config.authentication(AuthMethod::sql_server("sa", SA_PASSWORD));
+    config.trust_cert();
+
+    let tcp = TcpStream::connect(config.get_addr()).await.unwrap();
+    tcp.set_nodelay(true).unwrap();
+    let mut client = Client::connect(config, tcp.compat_write()).await.unwrap();
+
+    let sql = format!(
+        "IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = N'{}') CREATE DATABASE [{}]",
+        db_name, db_name
+    );
+    client.simple_query(sql.as_str()).await.unwrap();
+}
+
+fn make_config(host: String, port: u16, database: &str) -> DatabaseConfig {
+    DatabaseConfig {
+        name: "Test MSSQL".to_string(),
+        database: database.to_string(),
+        db_type: DbType::Mssql,
+        username: "sa".to_string(),
+        password: SA_PASSWORD.to_string(),
+        port,
+        host,
+        generated_id: "5a445eb4-c2c6-4bde-a423-ee1385dcf6d3".to_string(),
+        path: "".to_string(),
+    }
+}
+
+#[tokio::test]
+async fn mssql_ping_test() {
+    init_tracing_for_test();
+
+    let container = start_container().await;
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(1433).await.unwrap();
+    let config = make_config(host, port, "master");
+
+    let db = DatabaseFactory::create_for_backup(config).await;
+    let reachable = db.ping().await.unwrap_or(false);
+
+    assert!(reachable, "MSSQL ping should succeed");
+}
+
+#[tokio::test]
+async fn mssql_backup_test() {
+    init_tracing_for_test();
+
+    let container = start_container().await;
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(1433).await.unwrap();
+
+    create_user_database(&host, port, "backupdb").await;
+
+    let config = make_config(host, port, "backupdb");
+    let temp_dir = TempDir::new().unwrap();
+
+    let db = DatabaseFactory::create_for_backup(config).await;
+    let file_path = db.backup(temp_dir.path()).await.unwrap();
+
+    assert!(file_path.is_file(), "backup file should exist");
+    assert!(
+        file_path.metadata().unwrap().len() > 0,
+        "backup file should be non-empty"
+    );
+    assert!(
+        file_path.extension().and_then(|e| e.to_str()) == Some("bacpac"),
+        "backup file should have .bacpac extension"
+    );
+}
+
+#[tokio::test]
+async fn mssql_backup_restore_test() {
+    init_tracing_for_test();
+
+    let container = start_container().await;
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(1433).await.unwrap();
+
+    create_user_database(&host, port, "sourcedb").await;
+
+    let backup_config = make_config(host.clone(), port, "sourcedb");
+    let temp_dir = TempDir::new().unwrap();
+
+    let db = DatabaseFactory::create_for_backup(backup_config).await;
+    let file_path = db.backup(temp_dir.path()).await.unwrap();
+    assert!(file_path.is_file());
+
+    let compression = compress_to_tar_gz_large(&file_path).await.unwrap();
+    assert!(compression.compressed_path.is_file());
+
+    let files = decompress_large_tar_gz(
+        compression.compressed_path.as_path(),
+        temp_dir.path(),
+    )
+    .await
+    .unwrap();
+
+    let backup_file: PathBuf = if files.len() == 1 {
+        files[0].clone()
+    } else {
+        panic!("Unexpected number of files after decompression: {}", files.len());
+    };
+
+    let restore_config = make_config(host, port, "restoreddb");
+    let db_restore = DatabaseFactory::create_for_restore(restore_config, &backup_file).await;
+
+    match db_restore.restore(&backup_file).await {
+        Ok(_) => info!("MSSQL restore succeeded"),
+        Err(e) => {
+            error!("MSSQL restore failed: {:?}", e);
+            panic!("Restore failed: {:?}", e);
+        }
+    }
+}