chore: release 1.2.5

fix: new-workflow-ci (#32 )
* feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>
2026-09-11 02:27:10 +00:00 · 2026-03-08 20:50:53 +00:00 · 2026-03-08 21:48:13 +01:00 · 2026-03-08 20:20:58 +00:00 · 2026-03-08 21:18:27 +01:00 · 2026-03-08 20:00:47 +00:00
70 changed files with 1949 additions and 1267 deletions
@@ -0,0 +1,23 @@
+reviews:
+  auto_review:
+    enabled: true                  
+    ignore_usernames: ["dependabot[bot]"] 
+    labels: ["!wip", "!draft"]     
+  auto_apply_labels: true        
+  suggested_reviewers: true     
+  auto_assign_reviewers: true   
+
+issue_enrichment:
+  auto_enrich:
+    enabled: true                  
+  labeling:
+    auto_apply_labels: true        
+    labeling_instructions:
+      - label: bug
+        instructions: "Error, crash, or incorrect behavior reports"
+      - label: enhancement
+        instructions: "Feature requests or improvements"
+      - label: documentation
+        instructions: "Docs updates or missing documentation"
+      - label: good first issue
+        instructions: "Beginner-friendly tasks suitable for new contributors"
@@ -0,0 +1,73 @@
+name: Discord Notification
+
+on:
+  workflow_call:
+    inputs:
+      release_tag:
+        required: true
+        type: string
+      discord_title:
+        required: true
+        type: string
+      discord_color:
+        required: true
+        type: number
+      discord_footer:
+        required: true
+        type: string
+    secrets:
+      DISCORD_WEBHOOK:
+        required: true
+      GH_TOKEN:
+        required: true
+
+jobs:
+  notify-discord:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Discord Notification
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
+          GH_TOKEN: ${{ secrets.GH_TOKEN }}
+        run: |
+          RELEASE_INFO=$(gh release view "${{ inputs.release_tag }}" -R ${{ github.repository }} --json name,url,body,author)
+
+          RELEASE_TITLE=$(echo "$RELEASE_INFO" | jq -r .name)
+          if [ -z "$RELEASE_TITLE" ] || [ "$RELEASE_TITLE" = "null" ]; then RELEASE_TITLE="${{ inputs.release_tag }}"; fi
+
+          RELEASE_URL=$(echo "$RELEASE_INFO" | jq -r .url)
+          RELEASE_BODY=$(echo "$RELEASE_INFO" | jq -r .body)
+
+          AUTHOR_NAME="Portabase"
+          AUTHOR_ICON="https://github.com/Portabase.png"
+
+          PAYLOAD=$(jq -n \
+            --arg title "$RELEASE_TITLE" \
+            --arg description "$RELEASE_BODY" \
+            --arg url "$RELEASE_URL" \
+            --arg author "$AUTHOR_NAME" \
+            --arg icon "$AUTHOR_ICON" \
+            --arg discord_title "${{ inputs.discord_title }}" \
+            --arg discord_footer "${{ inputs.discord_footer }}" \
+            --argjson discord_color ${{ inputs.discord_color }} \
+            '{
+              content: $discord_title,
+              embeds: [{
+                title: $title,
+                url: $url,
+                description: $description,
+                color: $discord_color,
+                author: {
+                  name: $author,
+                  icon_url: $icon
+                },
+                footer: {
+                  text: $discord_footer
+                }
+              }]
+            }'
+          )
+
+          curl -H "Content-Type: application/json" \
+               -d "$PAYLOAD" \
+               "$DISCORD_WEBHOOK"
@@ -3,10 +3,16 @@ name: Docker Publish
 on:
  workflow_call:
    inputs:
+      version:
+        required: true
+        type: string
+      ref:
+        required: true
+        type: string
      image_name:
        required: false
        type: string
-        default: 'portabase/agent'
+        default: "portabase/agent"
      add_latest:
        required: false
        type: boolean
@@ -14,11 +20,11 @@ on:
      target:
        required: false
        type: string
-        default: 'prod'
+        default: "prod"
      dockerfile:
        required: false
        type: string
-        default: './docker/Dockerfile'
+        default: "./docker/Dockerfile"
    secrets:
      DOCKER_USERNAME:
        required: true
@@ -27,32 +33,34 @@ on:

 jobs:
  build:
-    name: Build and push Docker images
-    runs-on: ${{ matrix.platform == 'linux/amd64' && 'ubuntu-latest' || matrix.platform == 'linux/arm64' && 'ubuntu-24.04-arm' }}
+    name: Build architectures
+    runs-on: ${{ matrix.platform == 'linux/amd64' && 'ubuntu-latest' || 'ubuntu-24.04-arm' }}
    strategy:
      fail-fast: false
      matrix:
-        platform: [linux/amd64, linux/arm64]
+        platform: [ linux/amd64, linux/arm64 ]
    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+          fetch-depth: 0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3

      - name: Login to Docker
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

-      - name: Set image tag
-        id: set-tags
+      - name: Prepare Image Tags
+        id: prep
        run: |
-          REF_NAME=${GITHUB_REF#refs/tags/}
-          if [ "${{ matrix.platform }}" = "linux/amd64" ]; then
-            IMAGE="${{ inputs.image_name }}:$REF_NAME-amd64"
-          else
-            IMAGE="${{ inputs.image_name }}:$REF_NAME-arm64"
-          fi
-          echo "image=$IMAGE" >> $GITHUB_OUTPUT
+          ARCH=${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}
+          echo "image=${{ inputs.image_name }}:${{inputs.version}}-$ARCH" >> $GITHUB_OUTPUT
+          echo "safe_platform=${{ matrix.platform == 'linux/amd64' && 'linux-amd64' || 'linux-arm64' }}" >> $GITHUB_OUTPUT
+

      - name: Build and push image
        uses: docker/build-push-action@v6
@@ -61,57 +69,71 @@ jobs:
          file: ${{ inputs.dockerfile }}
          platforms: ${{ matrix.platform }}
          push: true
-          tags: ${{ steps.set-tags.outputs.image }}
+          tags: ${{ steps.prep.outputs.image }}
          target: ${{ inputs.target }}

-      - name: Prepare artifact name
-        id: artifact
-        run: |
-          platform=${{ matrix.platform }}
-          echo "safe_platform=${platform//\//-}" >> $GITHUB_OUTPUT
-          echo "${{ steps.set-tags.outputs.image }}" > image.txt
+      - name: Save image name for manifest
+        run: echo "${{ steps.prep.outputs.image }}" > image.txt

-      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f
+      - uses: actions/upload-artifact@v4
        with:
-          name: image-${{ steps.artifact.outputs.safe_platform }}
+          name: image-${{ steps.prep.outputs.safe_platform }}
          path: image.txt
-          if-no-files-found: warn
-          compression-level: 6
-          overwrite: false
-          include-hidden-files: false
+          retention-days: 1

  create-manifest:
-    name: Create multi-arch Docker manifest
+    name: Create multi-arch manifest
    runs-on: ubuntu-latest
    needs: build
    steps:
-      - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131
+      - uses: actions/download-artifact@v4
        with:
          name: image-linux-amd64
          path: /tmp/digests/amd64

-      - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131
+      - uses: actions/download-artifact@v4
        with:
          name: image-linux-arm64
          path: /tmp/digests/arm64

      - name: Login to Docker
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

+      - name: Generate semantic tags
+        id: tags
+        run: |
+          VERSION="${{ inputs.version }}"
+          IFS='.' read -r MAJOR MINOR PATCH <<< "$VERSION"
+          
+          echo "VERSION_TAG=$VERSION" >> $GITHUB_OUTPUT
+          if [ -n "$MINOR" ]; then
+            echo "MINOR_TAG=$MAJOR.$MINOR" >> $GITHUB_OUTPUT
+          fi
+          if [ -n "$MAJOR" ]; then
+            echo "MAJOR_TAG=$MAJOR" >> $GITHUB_OUTPUT
+          fi
+          if [ "${{ inputs.add_latest }}" = "true" ]; then
+            echo "LATEST_TAG=latest" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ inputs.image_name }}
+          tags: |
+            type=raw,value=${{ steps.tags.outputs.VERSION_TAG }}
+            type=raw,value=${{ steps.tags.outputs.MINOR_TAG }}
+            type=raw,value=${{ steps.tags.outputs.MAJOR_TAG }}
+            type=raw,value=${{ steps.tags.outputs.LATEST_TAG }}
+
      - name: Create and push manifest list
        working-directory: /tmp/digests
        run: |
          DOCKER_IMAGES="$(cat amd64/image.txt) $(cat arm64/image.txt)"
-          REF_NAME=${GITHUB_REF#refs/tags/}
-          MANIFEST_IMAGE="${{ inputs.image_name }}:$REF_NAME"
-
-          docker buildx imagetools create $DOCKER_IMAGES -t $MANIFEST_IMAGE
-          docker buildx imagetools inspect $MANIFEST_IMAGE
-
-          if [ "${{ inputs.add_latest }}" = "true" ]; then
-            docker buildx imagetools create $DOCKER_IMAGES -t ${{ inputs.image_name }}:latest
-            docker buildx imagetools inspect ${{ inputs.image_name }}:latest
-          fi
+          TAG_ARGS=$(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON")
+          echo $TAG_ARGS
+          docker buildx imagetools create $TAG_ARGS $DOCKER_IMAGES
@@ -1,128 +0,0 @@
-name: GitHub Release
-
-on:
-  workflow_call:
-    inputs:
-      prerelease:
-        required: false
-        type: boolean
-        default: false
-      make_latest:
-        required: false
-        type: boolean
-        default: false
-      discord_title:
-        required: true
-        type: string
-      discord_color:
-        required: true
-        type: number
-      discord_footer:
-        required: true
-        type: string
-    secrets:
-      DISCORD_WEBHOOK:
-        required: true
-      GH_TOKEN:
-        required: true
-
-jobs:
-  create-release:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Build Changelog
-        id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v5
-        with:
-          mode: "COMMIT"
-          configurationJson: |
-            {
-              "template": "#{{CHANGELOG}}",
-              "categories": [
-                {
-                    "title": "## Feature",
-                    "labels": ["feat", "feature"]
-                },
-                {
-                    "title": "## Fix",
-                    "labels": ["fix", "bug"]
-                },
-                {
-                    "title": "## Other",
-                    "labels": []
-                }
-              ],
-              "label_extractor": [
-                {
-                  "pattern": "^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test){1}(\([\w\-\.]+\))?(!)?: ([\w ])+([\s\S]*)",
-                  "on_property": "title",
-                  "target": "$1"
-                }
-              ]
-            }
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
-
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          generate_release_notes: false
-          body: ${{ steps.build_changelog.outputs.changelog }}
-          prerelease: ${{ inputs.prerelease }}
-          make_latest: ${{ inputs.make_latest }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
-
-      - name: Send Discord Notification
-        env:
-          DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
-          GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        run: |
-          RELEASE_INFO=$(gh release view "${{ github.ref_name }}" -R ${{ github.repository }} --json name,url,body,author)
-          
-          RELEASE_TITLE=$(echo "$RELEASE_INFO" | jq -r .name)
-          if [ -z "$RELEASE_TITLE" ] || [ "$RELEASE_TITLE" = "null" ]; then RELEASE_TITLE="${{ github.ref_name }}"; fi
-          
-          RELEASE_URL=$(echo "$RELEASE_INFO" | jq -r .url)
-          RELEASE_BODY=$(echo "$RELEASE_INFO" | jq -r .body)
-          
-          AUTHOR_NAME="Portabase"
-          AUTHOR_ICON="https://github.com/Portabase.png" 
-
-          PAYLOAD=$(jq -n \
-            --arg title "$RELEASE_TITLE" \
-            --arg description "$RELEASE_BODY" \
-            --arg url "$RELEASE_URL" \
-            --arg author "$AUTHOR_NAME" \
-            --arg icon "$AUTHOR_ICON" \
-            --arg discord_title "${{ inputs.discord_title }}" \
-            --arg discord_footer "${{ inputs.discord_footer }}" \
-            --argjson discord_color ${{ inputs.discord_color }} \
-            '{ 
-              content: $discord_title,
-              embeds: [{
-                title: $title,
-                url: $url,
-                description: $description,
-                color: $discord_color,
-                author: {
-                  name: $author,
-                  icon_url: $icon
-                },
-                footer: {
-                  text: $discord_footer
-                }
-              }]
-            }'
-          ) 
-          
-          curl -H "Content-Type: application/json" \
-               -d "$PAYLOAD" \
-               "$DISCORD_WEBHOOK"
@@ -1,32 +1,138 @@
-name: Publish Docker image for release
+name: Auto Release & Publish

 on:
-  push:
-    tags:
-      - '*.*.*'
-      - '!*-*'
+  pull_request:
+    types: [ closed ]
+    branches:
+      - main

 permissions:
  contents: write
  packages: write

 jobs:
-  docker_publish:
+
+  check-skip:
+    runs-on: ubuntu-latest
+    outputs:
+      skip: ${{ steps.set-skip.outputs.skip }}
+    steps:
+      - name: Determine if release should be skipped
+        id: set-skip
+        run: |
+          TITLE="${{ github.event.pull_request.title }}"
+          echo "PR title: $TITLE"
+
+          if [[ "$TITLE" == *"[skip-release]"* ]]; then
+            echo "PR title contains [skip-release], skipping release jobs."
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+  create-release:
+    needs: check-skip
+    if: ${{ needs.check-skip.outputs.skip == 'false' }}
+    runs-on: ubuntu-latest
+    outputs:
+      draft_tag: ${{ steps.release_step.outputs.draft_tag }}
+      version: ${{ steps.release_step.outputs.version }}
+    steps:
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ vars.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ steps.app-token.outputs.token }}
+          ref: main
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install cargo-edit
+        run: cargo install cargo-edit
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+
+      - name: Install release-it globally
+        run: |
+          npm install -g release-it
+          npm install -g @release-it/conventional-changelog
+          npm install -g @release-it/bumper
+
+      - run: |
+          git config --global user.name 'github-actions[bot]'
+          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+
+      - name: Run release-it
+        id: release_step
+        run: |
+          git pull origin main
+
+          VERSION=$(release-it --ci --release-version)
+          echo $VERSION
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+          OUTPUT=$(release-it --ci)
+          echo "$OUTPUT"
+
+          DRAFT_TAG=$(echo "$OUTPUT" | grep -oE 'untagged-[a-z0-9]+')
+          echo $DRAFT_TAG
+          echo "draft_tag=$DRAFT_TAG" >> $GITHUB_OUTPUT
+        env:
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
+
+  publish-docker:
+    needs: create-release
+    if: ${{ needs.create-release.result == 'success' }}
    uses: ./.github/workflows/docker.yml
    with:
+      version: ${{ needs.create-release.outputs.version }}
+      ref: ${{ needs.create-release.outputs.version }}
      add_latest: true
    secrets:
      DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
      DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}

-  github_release:
-    needs: docker_publish
-    uses: ./.github/workflows/github.yml
+
+  finalize-release:
+    needs:
+      - create-release
+      - publish-docker
+    runs-on: ubuntu-latest
+    outputs:
+      release_tag: ${{ steps.publish_release_step.outputs.release_tag }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Publish GitHub Release
+        id: publish_release_step
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          OUTPUT=$(gh release edit ${{ needs.create-release.outputs.draft_tag }} --draft=false)
+          echo "$OUTPUT"
+          RELEASE_TAG=$(echo "$OUTPUT" | sed -E 's|.*/releases/tag/||')
+          echo "release_tag=$RELEASE_TAG" >> $GITHUB_OUTPUT
+
+  notify-discord:
+    needs:
+      - publish-docker
+      - create-release
+      - finalize-release
+    uses: ./.github/workflows/discord.yml
    with:
-      prerelease: false
-      make_latest: true
+      release_tag: ${{ needs.create-release.outputs.version }}
      discord_title: "||@release-agent|| New release published"
-      discord_color: 5814783
+      discord_color: 3066993
      discord_footer: "Portabase"
    secrets:
      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
@@ -0,0 +1,62 @@
+{
+  "github": {
+    "release": true,
+    "draft": true,
+    "tokenRef": "GITHUB_TOKEN"
+  },
+  "git": {
+    "commit": true,
+    "commitMessage": "chore: release ${version}",
+    "requireCleanWorkingDir": true,
+    "tag": true,
+    "tagName": "${version}",
+    "push": true
+  },
+  "hooks": {
+    "before:bump": "cargo set-version ${version}"
+  },
+  "plugins": {
+    "@release-it/conventional-changelog": {
+      "preset": {
+        "name": "conventionalcommits",
+        "types": [
+          {
+            "type": "feat",
+            "section": "✨ Features"
+          },
+          {
+            "type": "fix",
+            "section": "🐛 Bug Fixes"
+          },
+          {
+            "type": "perf",
+            "section": "⚡️ Performance Improvements"
+          },
+          {
+            "type": "revert",
+            "section": "⏪️ Reverts"
+          },
+          {
+            "type": "docs",
+            "section": "📝 Documentation",
+            "hidden": true
+          },
+          {
+            "type": "chore",
+            "section": "🔧 Chores",
+            "hidden": true
+          }
+        ]
+      }
+    },
+    "@release-it/bumper": {
+      "out": [
+        {
+          "file": "CITATION.cff",
+          "path": "version",
+          "type": "text/yaml"
+        }
+      ]
+    }
+  }
+}
@@ -1,6 +1,6 @@
 cff-version: 1.2.0
 title: Portabase Agent (Rust)
-message: "If you use this software, please cite it as below."
+message: If you use this software, please cite it as below.
 type: software
 authors:
  - family-names: Gauthereau
@@ -9,7 +9,12 @@ authors:
    given-names: Killian
 repository-code: https://github.com/Portabase/agent-rust
 url: https://portabase.io
-abstract: "Portabase is a free, open-source, self-hosted solution for database administration, providing backup and restore capabilities, scheduling, retention policies, notifications, and support for multiple storage backends. Its headless agent architecture enables connection to multiple database instances securely and efficiently."
+abstract: >-
+  Portabase is a free, open-source, self-hosted solution for database
+  administration, providing backup and restore capabilities, scheduling,
+  retention policies, notifications, and support for multiple storage backends.
+  Its headless agent architecture enables connection to multiple database
+  instances securely and efficiently.
 keywords:
  - database
  - administration
@@ -22,5 +27,5 @@ keywords:
  - self-hosted
  - portabase
 license: Apache-2.0
-version: 1.1.5
-date-released: "2026-02-19"
+version: 1.2.5
+date-released: '2026-02-24'
@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.1.5"
+version = "1.2.5"
 edition = "2024"

 [dependencies]
@@ -30,4 +30,21 @@ seed-postgres-1gb:
 	docker exec -i -e PGPASSWORD=$$PG_PASSWORD $$PG_CONTAINER \
 		psql -U $$PG_USER -d $$PG_DB < ./scripts/postgres/seed-1gb.sql

+
+SQLITE_SEED_FILE := $(if $(filter big,$(SEED)),./scripts/sqlite/seed-big.sql,./scripts/sqlite/seed.sql)
+
+seed-sqlite:
+	@echo "Seeding Sqlite..."
+	@echo "Run as root to fix permissions inside the volume"
+	docker exec -u 0 -it db-sqlite sh -c "chmod -R 777 /workspace/data"
+	@echo "Create the database file (if it doesn’t exist)"
+	docker exec -u 0 -it db-sqlite sh -c "touch /workspace/data/app.db"
+	@echo "Seed the database"
+	docker exec -i db-sqlite sh -c "sqlite3 /workspace/data/app.db" < $(SQLITE_SEED_FILE)
+	@echo "Verify"
+	docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT name FROM sqlite_master WHERE type='table';"
+	@echo "Done"
+
+
+
 seed-all: seed-mongo seed-mysql seed-postgres seed-postgres-1gb
@@ -19,6 +19,7 @@
 [![PostgreSQL](https://img.shields.io/badge/python-3.13-blue.svg)](https://www.python.org/downloads/release/python-3120/)
 [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-336791?logo=postgresql&logoColor=white)](https://www.postgresql.org/)
 [![MySQL](https://img.shields.io/badge/MySQL-4479A1?logo=mysql&logoColor=white)](https://www.mysql.com/)
+[![SQLite](https://img.shields.io/badge/-SQLite-blue?logo=sqlite&logoColor=white)](https://sqlite.org/)
 [![MariaDB](https://img.shields.io/badge/MariaDB-003545?logo=mariadb&logoColor=white)](https://mariadb.org/)
 [![MongoDB](https://img.shields.io/badge/-MongoDB-13aa52?logo=mongodb&logoColor=white)](https://www.mongodb.com/)
 [![Self Hosted](https://img.shields.io/badge/self--hosted-yes-brightgreen)](https://github.com/Portabase/portabase)
@@ -79,3 +80,5 @@ Distributed under the Apache License. See `LICENSE.txt` for more information.

 [Docker-url]: https://www.docker.com/

+
+
@@ -34,11 +34,21 @@
      "name": "Test database 5 - MongoDB",
      "database": "testdb",
      "type": "mongodb",
-      "username": "",
-      "password": "",
      "port": 27017,
      "host": "db-mongodb",
      "generated_id": "16678147-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 6 - SQLite DB",
+      "type": "sqlite",
+      "path": "/sqlite-data/workspace/data/app.db",
+      "generated_id": "16678178-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 7 - SQLite DB",
+      "type": "sqlite",
+      "path": "/sqlite-data-2/workspace/data/app.db",
+      "generated_id": "16678179-ff7e-4c97-8c83-0adeff214681"
    }
  ]
 }
@@ -11,12 +11,14 @@ services:
      #      - ./databases.toml:/config/config.toml
      - cargo-registry:/usr/local/cargo/registry
      - cargo-git:/usr/local/cargo/git
-#      - cargo-target:/app/target
+      #      - cargo-target:/app/target
+#      - sqlite-data:/sqlite-data/workspace/data
+#      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
    environment:
      APP_ENV: development
      LOG: debug
      TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiZjg4Y2E0MDMtNDgwOS00NGM4LTlkZjItY2VkNWYwYzhkNTM2IiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNjI1MDQzY2YtN2MwMC00M2M4LWJjYzktZDM1MTk5ODk2ZGNkIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
      #POOLING: 1
      #DATABASES_CONFIG_FILE: "config.toml"
    extra_hosts:
@@ -37,22 +39,22 @@ services:
      - POSTGRES_PASSWORD=changeme
    networks:
      - portabase
-
-  db-mariadb:
-    container_name: db-mariadb
-    image: mariadb:latest
-    ports:
-      - "3311:3306"
-    environment:
-      - MYSQL_DATABASE=mariadb
-      - MYSQL_USER=mariadb
-      - MYSQL_PASSWORD=changeme
-      - MYSQL_RANDOM_ROOT_PASSWORD=yes
-    volumes:
-      - mariadb-data:/var/lib/mysql
-    networks:
-      - portabase
-
+#
+#  db-mariadb:
+#    container_name: db-mariadb
+#    image: mariadb:latest
+#    ports:
+#      - "3311:3306"
+#    environment:
+#      - MYSQL_DATABASE=mariadb
+#      - MYSQL_USER=mariadb
+#      - MYSQL_PASSWORD=changeme
+#      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+#    volumes:
+#      - mariadb-data:/var/lib/mysql
+#    networks:
+#      - portabase
+#
 #
 #  db-mongodb-auth:
 #    container_name: db-mongodb-auth
@@ -91,16 +93,27 @@ services:
 #    networks:
 #      - portabase

+#  sqlite:
+#    container_name: db-sqlite
+#    image: keinos/sqlite3
+#    volumes:
+#      - sqlite-data:/workspace/data
+#    working_dir: /workspace
+#    command: tail -f /dev/null
+#    stdin_open: true
+#    tty: true
+
+
 volumes:
  cargo-registry:
  cargo-git:
-#  cargo-target:
-
+  #  cargo-target:

  postgres-data:
-  mariadb-data:
+#  mariadb-data:
 #  mongodb-data:
 #  mongodb-data-auth:
+#  sqlite-data:

 networks:
  portabase:
@@ -15,6 +15,7 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
    zlib1g \
    curl \
    mariadb-client \
+    sqlite3 \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

@@ -92,6 +93,7 @@ RUN apt-get update && apt-get install -y \
    libncurses6 \
    zlib1g \
    mariadb-client \
+    sqlite3 \
    && rm -rf /var/lib/apt/lists/*


@@ -1,99 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ -z "$1" ]; then
-  echo "Usage: ./release <version>"
-  echo "Example: ./release v1.0.0"
-  exit 1
-fi
-
-VERSION=$1
-CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-
-if [ "$CURRENT_BRANCH" = "main" ]; then
-  if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-    echo "Error: On 'main' branch, only release tags (X.Y.Z) are allowed."
-    exit 1
-  fi
-else
-  if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+-rc\.[0-9]+$ ]]; then
-    echo "Error: On branch '$CURRENT_BRANCH', only RC tags matching X.Y.Z-rc.W are allowed (e.g., 1.0.0-rc.1)."
-    exit 1
-  fi
-fi
-
-CLEAN_VERSION=${VERSION#v}
-CURRENT_DATE=$(date +%Y-%m-%d)
-
-echo "Preparing release $VERSION..."
-
-
-# package.json
-if [ -f package.json ]; then
-  echo "Updating package.json..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/\"version\": \".*\"/\"version\": \"$CLEAN_VERSION\"/" package.json
-  else
-    sed -i '' "s/\"version\": \".*\"/\"version\": \"$CLEAN_VERSION\"/" package.json
-  fi
-fi
-
-# pyproject.toml
-if [ -f pyproject.toml ]; then
-  echo "Updating pyproject.toml..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" pyproject.toml
-  else
-    sed -i '' "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" pyproject.toml
-  fi
-fi
-
-# Cargo.toml
-if [ -f Cargo.toml ]; then
-  echo "Updating Cargo.toml..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" Cargo.toml
-  else
-    sed -i '' "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" Cargo.toml
-  fi
-fi
-
-# CITATION.cff
-if [ -f CITATION.cff ]; then
-  echo "Updating CITATION.cff..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/^version: .*/version: $CLEAN_VERSION/" CITATION.cff
-    sed -i "s/^date-released: .*/date-released: \"$CURRENT_DATE\"/" CITATION.cff
-  else
-    sed -i '' "s/^version: .*/version: $CLEAN_VERSION/" CITATION.cff
-    sed -i '' "s/^date-released: .*/date-released: \"$CURRENT_DATE\"/" CITATION.cff
-  fi
-fi
-
-
-
-
-
-git add .
-
-if ! git diff-index --quiet HEAD --; then
-  echo "Committing changes..."
-  git commit -m "chore(release): $VERSION"
-else
-  echo "No changes to commit. Proceeding to tag..."
-fi
-
-if git rev-parse "$VERSION" >/dev/null 2>&1; then
-    echo "Tag $VERSION already exists. Aborting."
-    exit 1
-fi
-
-echo "Creating tag $VERSION..."
-git tag -a "$VERSION" -m "Release $VERSION"
-
-echo "Pushing changes and tags to remote..."
-git push
-git push origin "$VERSION"
-
-echo "Successfully released $VERSION!"
@@ -1,6 +1,5 @@
 # Seed instructions

-## MongoDB

 ```bash
 make seed-mongo     
@@ -9,5 +8,19 @@ make seed-mysql
 make seed-mysql-1gb    
 make seed-postgres      
 make seed-postgres-1gb  
-make seed-all      
+make seed-all   
+make seed-sqlite   
+make seed-sqlite SEED=big   
+```
+
+## Verify commands 
+
+### Sqlite
+
+```bash
+docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT * FROM users LIMIT 10;"  
+```
+
+```bash
+docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT name FROM sqlite_master WHERE type='table';"
 ```
@@ -60,7 +60,7 @@ SELECT
    )
 FROM users u
         JOIN generate_series(1, 30) AS p(post_no)
-              ON u.id <= 300000;
+              ON u.id <= 500000;

 -- ============================================================
 -- OPTIONAL: FORCE DISK MATERIALIZATION
@@ -0,0 +1,74 @@
+PRAGMA foreign_keys = ON;
+BEGIN TRANSACTION;
+
+-- Drop tables
+DROP TABLE IF EXISTS users;
+DROP TABLE IF EXISTS projects;
+DROP TABLE IF EXISTS tasks;
+
+-- Users
+CREATE TABLE users (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       email TEXT NOT NULL UNIQUE,
+                       full_name TEXT NOT NULL,
+                       role TEXT NOT NULL CHECK (role IN ('admin','manager','user')),
+                       created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Projects
+CREATE TABLE projects (
+                          id INTEGER PRIMARY KEY AUTOINCREMENT,
+                          name TEXT NOT NULL,
+                          description TEXT,
+                          owner_id INTEGER NOT NULL,
+                          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                          FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Tasks
+CREATE TABLE tasks (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       project_id INTEGER NOT NULL,
+                       title TEXT NOT NULL,
+                       status TEXT NOT NULL CHECK (status IN ('todo','in_progress','done')),
+                       priority INTEGER NOT NULL DEFAULT 3,
+                       due_date TEXT,
+                       created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+);
+
+-- Seed minimal users
+INSERT INTO users (email, full_name, role) VALUES
+                                               ('admin@example.com', 'System Admin', 'admin'),
+                                               ('manager@example.com', 'Project Manager', 'manager'),
+                                               ('user@example.com', 'Standard User', 'user');
+
+-- Generate 10_000 projects
+WITH RECURSIVE numbers(x) AS (
+    SELECT 1
+    UNION ALL
+    SELECT x+1 FROM numbers WHERE x<10000
+)
+INSERT INTO projects (name, description, owner_id)
+SELECT
+    'Project #' || x,
+    'Auto-generated project description for project #' || x,
+    (1 + (x % 3)) -- cycle users 1..3
+FROM numbers;
+
+-- Generate 100_000 tasks
+WITH RECURSIVE numbers(x) AS (
+    SELECT 1
+    UNION ALL
+    SELECT x+1 FROM numbers WHERE x<100000
+)
+INSERT INTO tasks (project_id, title, status, priority, due_date)
+SELECT
+    (1 + (x % 10000)), -- project id cycle
+    'Task #' || x,
+    CASE (x % 3) WHEN 0 THEN 'todo' WHEN 1 THEN 'in_progress' ELSE 'done' END,
+    1 + (x % 5),
+    date('now', '+' || (x % 30) || ' days')
+FROM numbers;
+
+COMMIT;
@@ -0,0 +1,59 @@
+PRAGMA foreign_keys = ON;
+
+BEGIN TRANSACTION;
+
+-- Drop existing tables (idempotent reset)
+DROP TABLE IF EXISTS users;
+DROP TABLE IF EXISTS projects;
+DROP TABLE IF EXISTS tasks;
+
+-- Users
+CREATE TABLE users (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       email TEXT NOT NULL UNIQUE,
+                       full_name TEXT NOT NULL,
+                       role TEXT NOT NULL CHECK (role IN ('admin','manager','user')),
+                       created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Projects
+CREATE TABLE projects (
+                          id INTEGER PRIMARY KEY AUTOINCREMENT,
+                          name TEXT NOT NULL,
+                          description TEXT,
+                          owner_id INTEGER NOT NULL,
+                          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                          FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Tasks
+CREATE TABLE tasks (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       project_id INTEGER NOT NULL,
+                       title TEXT NOT NULL,
+                       status TEXT NOT NULL CHECK (status IN ('todo','in_progress','done')),
+                       priority INTEGER NOT NULL DEFAULT 3,
+                       due_date TEXT,
+                       created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+);
+
+-- Seed users
+INSERT INTO users (email, full_name, role) VALUES
+                                               ('admin@example.com', 'System Admin', 'admin'),
+                                               ('manager@example.com', 'Project Manager', 'manager'),
+                                               ('user@example.com', 'Standard User', 'user');
+
+-- Seed projects
+INSERT INTO projects (name, description, owner_id) VALUES
+                                                       ('Internal Tooling', 'Backoffice automation platform', 2),
+                                                       ('Client Portal', 'Customer-facing SaaS interface', 2);
+
+-- Seed tasks
+INSERT INTO tasks (project_id, title, status, priority, due_date) VALUES
+                                                                      (1, 'Define architecture', 'done', 1, date('now', '+3 days')),
+                                                                      (1, 'Implement authentication', 'in_progress', 1, date('now', '+7 days')),
+                                                                      (2, 'Design landing page', 'todo', 2, date('now', '+5 days')),
+                                                                      (2, 'Setup CI/CD', 'todo', 2, date('now', '+10 days'));
+
+COMMIT;
@@ -6,6 +6,7 @@ use crate::services::config::{DatabaseConfig, DbType};
 use anyhow::Result;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
+use crate::domain::sqlite::database::SqliteDatabase;

 #[async_trait::async_trait]
 pub trait Database: Send + Sync {
@@ -27,6 +28,7 @@ impl DatabaseFactory {
            DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
            DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
            DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
+            DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
        }
    }

@@ -39,6 +41,7 @@ impl DatabaseFactory {
            DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
            DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
            DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
+            DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
        }
    }
 }
@@ -2,4 +2,5 @@ pub mod factory;
 pub mod postgres;
 pub mod mysql;
 mod mongodb;
+mod sqlite;

@@ -15,7 +15,7 @@ pub async fn run(

        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
        let mongodump = select_mongo_path().join("mongodump");
-        let uri = get_mongo_uri(cfg.clone());
+        let uri = get_mongo_uri(cfg.clone())?;

        let output = Command::new(mongodump)
            .arg(format!("--uri={}", uri))
@@ -3,7 +3,7 @@ use anyhow::Result;
 use mongodb::Client;

 pub async fn connect(cfg: DatabaseConfig) -> Result<Client> {
-    let uri = get_mongo_uri(cfg);
+    let uri = get_mongo_uri(cfg)?;
    let mut options = mongodb::options::ClientOptions::parse(&uri).await?;
    options.server_selection_timeout = Some(std::time::Duration::from_secs(3));
    options.connect_timeout = Some(std::time::Duration::from_secs(3));
@@ -15,14 +15,16 @@ pub fn select_mongo_path() -> std::path::PathBuf {
    "/usr/local/mongodb/bin".to_string().into()
 }

-pub fn get_mongo_uri(cfg: DatabaseConfig) -> String {
-    if cfg.username.is_empty() {
-        format!("mongodb://{}:{}/{}", cfg.host, cfg.port, cfg.database)
+pub fn get_mongo_uri(cfg: DatabaseConfig) -> Result<String> {

+    if cfg.username.is_empty() || cfg.password.is_empty() {
+        Ok(format!("mongodb://{}:{}/{}", cfg.host, cfg.port, cfg.database))
    } else {
-        format!(
+        Ok(format!(
            "mongodb://{}:{}@{}:{}/{}?authSource=admin",
            cfg.username, cfg.password, cfg.host, cfg.port, cfg.database
-        )
+        ))
    }
 }
+
+
@@ -1,14 +1,20 @@
 #![allow(dead_code)]

+use crate::domain::mongodb::connection::connect;
 use crate::services::config::DatabaseConfig;
 use anyhow::Result;
 use mongodb::bson::doc;
-use tracing::{error};
-use crate::domain::mongodb::connection::connect;
+use tracing::error;

 pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
    let client = connect(cfg.clone()).await?;
-    let db_name = if cfg.username.is_empty() { &cfg.database } else { "admin" };
+
+    let db_name = if cfg.username.is_empty() && cfg.password.is_empty() {
+        &cfg.database
+    } else {
+        "admin"
+    };
+
    match client.database(db_name).run_command(doc! {"ping": 1}).await {
        Ok(_) => Ok(true),
        Err(e) => {
@@ -10,7 +10,7 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
        debug!("Starting MongoDB restore for database {}", cfg.name);

        let mongorestore = select_mongo_path().join("mongorestore");
-        let uri = get_mongo_uri(cfg.clone());
+        let uri = get_mongo_uri(cfg.clone())?;

        let output = Command::new(mongorestore)
            .arg(format!("--uri={}", uri))
@@ -1,4 +1,4 @@
-use crate::domain::mysql::connection::server_version;
+use crate::domain::mysql::connection::{server_version};
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::collections::HashMap;
@@ -3,6 +3,7 @@ use std::process::Command;
 use anyhow::Result;

 pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
+
    let output = Command::new("mysql")
        .arg("--host").arg(&cfg.host)
        .arg("--port").arg(cfg.port.to_string())
@@ -25,3 +26,4 @@ pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {

    Ok(version)
 }
+
@@ -21,7 +21,7 @@ impl MySQLDatabase {

    fn build_env(&self) -> HashMap<String, String> {
        let mut envs = std::env::vars().collect::<HashMap<_, _>>();
-        envs.insert("MYSQL_PWD".to_string(), self.cfg.password.clone());
+        envs.insert("MYSQL_PWD".to_string(), self.cfg.password.to_string());
        envs
    }
 }
@@ -4,6 +4,7 @@ use tokio::process::Command;
 use tokio::time::{Duration, timeout};

 pub async fn run(cfg: DatabaseConfig, env: HashMap<String, String>) -> anyhow::Result<bool> {
+
    let mut cmd = Command::new("mysqladmin");
    cmd.arg("--host")
        .arg(cfg.host)
@@ -1,11 +1,10 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
 use std::fs::File;
 use std::io::{Read, Write};
-use anyhow::{Context, Result};
-use tracing::{debug, error, info};
 use std::path::PathBuf;
 use std::process::Command;
-
-use crate::services::config::DatabaseConfig;
+use tracing::{debug, error, info};

 pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
    let handle = tokio::task::spawn_blocking(move || -> Result<()> {
@@ -55,7 +54,8 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
            .with_context(|| format!("Failed to start mysql restore for {}", cfg.name))?;

        let mut stdin = child.stdin.take().context("Failed to open child stdin")?;
-        stdin.write_all(sql_content.as_bytes())
+        stdin
+            .write_all(sql_content.as_bytes())
            .context("Failed to write SQL content to mysql stdin")?;
        stdin.flush()?;
        drop(stdin);
@@ -74,8 +74,7 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
        Ok(())
    });

-    handle
-        .await??;
+    handle.await??;

    Ok(())
 }
@@ -1,7 +1,7 @@
 use anyhow::Result;
-use tracing::{debug, error, info};
 use std::path::PathBuf;
 use std::process::Command;
+use tracing::{debug, error, info};

 use super::connection::{select_pg_path, server_version};
 use super::format::PostgresDumpFormat;
@@ -1,11 +1,12 @@
-use std::path::Path;
 use crate::domain::postgres::format::PostgresDumpFormat;
 use crate::services::config::DatabaseConfig;
 use anyhow::Result;
+use std::path::Path;
 use tokio_postgres::{Client, NoTls};
-use tracing::info;
+use tracing::{error, info};

 pub async fn connect(cfg: &DatabaseConfig) -> Result<Client> {
+    info!("Connecting to postgres database {}:{}", cfg.host, cfg.port);
    let dsn = format!(
        "host={} port={} user={} password={} dbname={}",
        cfg.host, cfg.port, cfg.username, cfg.password, cfg.database
@@ -14,7 +15,7 @@ pub async fn connect(cfg: &DatabaseConfig) -> Result<Client> {
    let (client, connection) = tokio_postgres::connect(&dsn, NoTls).await?;
    tokio::spawn(async move {
        if let Err(e) = connection.await {
-            tracing::error!("Postgres connection error: {}", e);
+            error!("Postgres connection error: {}", e);
        }
    });
    Ok(client)
@@ -34,7 +35,7 @@ pub fn select_pg_path(version: &str) -> std::path::PathBuf {

 pub async fn terminate_connections(cfg: &DatabaseConfig) -> Result<()> {
    let mut admin = cfg.clone();
-    admin.database = "postgres".into();
+    admin.database = "postgres".to_string().into();

    let client = connect(&admin).await?;

@@ -39,7 +39,6 @@ impl Database for PostgresDatabase {
        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
        let res = backup::run(self.cfg.clone(), self.format, dir.to_path_buf()).await;
        FileLock::release(&self.cfg.generated_id).await?;
-
        res
    }

@@ -1,7 +1,7 @@
 use anyhow::Result;
-use tracing::{debug, error, info};
 use std::path::PathBuf;
 use std::process::Command;
+use tracing::{debug, error, info};

 use super::connection::{select_pg_path, server_version, terminate_connections};
 use super::format::PostgresDumpFormat;
@@ -14,6 +14,7 @@ pub async fn run(
 ) -> Result<()> {
    tokio::task::spawn_blocking(move || -> Result<()> {
        debug!("Starting restore for database {}", cfg.name);
+
        let version = match futures::executor::block_on(server_version(&cfg)) {
            Ok(v) => {
                debug!("Postgres version detected: {}", v);
@@ -91,8 +92,6 @@ pub async fn run(
                let dec = flate2::read::GzDecoder::new(tar_gz);
                let mut archive = tar::Archive::new(dec);

-
-
                let tmp_dir = match tempfile::TempDir::new() {
                    Ok(d) => d,
                    Err(e) => {
@@ -104,8 +103,6 @@ pub async fn run(
                    }
                };

-
-
                if let Err(e) = archive.unpack(tmp_dir.path()) {
                    error!("Failed to unpack FD archive for {}: {:?}", cfg.name, e);
                    return Err(e.into());
@@ -113,7 +110,6 @@ pub async fn run(

                debug!("Listing contents of temp dir: {}", tmp_dir.path().display());

-
                for entry in std::fs::read_dir(tmp_dir.path())? {
                    if let Ok(entry) = entry {
                        let path = entry.path();
@@ -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,
+    backup_dir: PathBuf,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting SQLite backup for database {}", cfg.name);
+
+        let db_path_str = if cfg.path.is_empty() {
+            anyhow::bail!("Database path not configured");
+        } else {
+            cfg.path.as_str().to_string()
+        };
+
+        let db_path = PathBuf::from(db_path_str);
+
+        if !db_path.exists() {
+            anyhow::bail!("SQLite database file not found: {}", db_path.display());
+        }
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+
+        let output = Command::new("sqlite3")
+            .arg(db_path.as_os_str())
+            .arg(format!(".backup '{}'", file_path.display()))
+            .output()
+            .context("SQLite backup command failed to start")?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("SQLite backup failed for {}: {}", cfg.name, stderr);
+            anyhow::bail!("SQLite backup failed for {}: {}", cfg.name, stderr);
+        }
+
+        info!("SQLite backup completed for {}", cfg.name);
+        Ok(file_path)
+    })
+        .await?
+}
@@ -0,0 +1,43 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+
+use super::{backup, ping, restore};
+use crate::domain::factory::Database;
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+
+pub struct SqliteDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl SqliteDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for SqliteDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".backup"
+    }
+
+    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
+    }
+}
@@ -0,0 +1,4 @@
+mod backup;
+mod restore;
+mod ping;
+pub mod database;
@@ -0,0 +1,5 @@
+use crate::services::config::DatabaseConfig;
+
+pub async fn run(_cfg: DatabaseConfig) -> anyhow::Result<bool> {
+    Ok(true)
+}
@@ -0,0 +1,44 @@
+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 SQLite restore for database {}", cfg.name);
+
+        let db_path_str = if cfg.path.is_empty() {
+            anyhow::bail!("Database path not configured");
+        } else {
+            cfg.path.as_str().to_string()
+        };
+
+        let db_path = PathBuf::from(db_path_str);
+
+        if !restore_file.exists() {
+            anyhow::bail!("Restore file not found: {}", restore_file.display());
+        }
+
+        if db_path.exists() {
+            std::fs::remove_file(&db_path)
+                .with_context(|| format!("Failed to remove existing DB {}", db_path.display()))?;
+        }
+
+        let output = Command::new("sqlite3")
+            .arg(db_path.as_os_str())
+            .arg(format!(".restore '{}'", restore_file.display()))
+            .output()
+            .with_context(|| format!("Failed to run sqlite3 restore for {}", cfg.name))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("SQLite restore failed for {}: {}", cfg.name, stderr);
+            anyhow::bail!("SQLite restore failed for {}", cfg.name);
+        }
+
+        info!("SQLite restore completed for {}", cfg.name);
+        Ok(())
+    })
+    .await?
+}
@@ -1,2 +1,3 @@
 pub mod status;
-pub mod backup;
+pub mod backup;
+pub mod restore;
@@ -0,0 +1,33 @@
+use crate::services::api::models::agent::restore::ResultRestoreResponse;
+use crate::services::api::{ApiClient, ApiError};
+use anyhow::Result;
+use reqwest::Method;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct ResultRestoreRequest {
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    pub status: String,
+}
+
+impl ApiClient {
+    pub async fn restore_result(
+        &self,
+        agent_id: impl Into<String>,
+        generated_id: impl Into<String>,
+        status: impl Into<String>,
+    ) -> Result<Option<ResultRestoreResponse>, ApiError> {
+        let body = ResultRestoreRequest {
+            generated_id: generated_id.into(),
+            status: status.into(),
+        };
+
+        let agent_id = agent_id.into();
+
+        let path = format!("/agent/{}/restore", agent_id);
+
+        self.request_with_body(Method::POST, path.as_str(), &body)
+            .await
+    }
+}
@@ -1,2 +1,3 @@
 pub mod status;
-pub mod backup;
+pub mod backup;
+pub mod restore;
@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ResultRestoreResponse {
+    pub message: String,
+    pub status: bool,
+}
@@ -1,415 +0,0 @@
-#![allow(dead_code)]
-
-use crate::core::context::Context as CoreContext;
-use crate::domain::factory::DatabaseFactory;
-use crate::services::api::models::agent::status::DatabaseStorage;
-use crate::services::config::{DatabaseConfig, DatabasesConfig, DbType};
-use crate::services::storage;
-use crate::utils::common::BackupMethod;
-use crate::utils::compress::compress_to_tar_gz_large;
-use anyhow::Result;
-use futures::future::join_all;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use tempfile::TempDir;
-use tracing::{error, info};
-use crate::utils::locks::FileLock;
-
-#[derive(Debug, Clone)]
-pub struct BackupResult {
-    pub generated_id: String,
-    pub db_type: DbType,
-    pub status: String,
-    pub backup_file: Option<PathBuf>,
-    pub code: Option<String>,
-}
-
-#[derive(Debug)]
-pub struct UploadResult {
-    pub storage_id: String,
-    pub success: bool,
-    pub error: Option<String>,
-    pub remote_file_path: Option<String>,
-    pub total_size: Option<u64>,
-}
-
-pub struct BackupService {
-    ctx: Arc<CoreContext>,
-}
-
-impl BackupService {
-    pub fn new(ctx: Arc<CoreContext>) -> Self {
-        Self { ctx }
-    }
-
-    pub async fn dispatch(
-        &self,
-        generated_id: &String,
-        config: &DatabasesConfig,
-        method: BackupMethod,
-        storages: &Vec<DatabaseStorage>,
-        encrypt: bool,
-    ) {
-        if let Some(cfg) = config
-            .databases
-            .iter()
-            .find(|c| c.generated_id == generated_id.as_str())
-        {
-            let db_cfg = cfg.clone();
-            let ctx = self.ctx.clone();
-            let storages_clone = storages.clone();
-            let generated_id_clone = generated_id.clone();
-
-            tokio::spawn(async move {
-                match TempDir::new() {
-                    Ok(temp_dir) => {
-                        match FileLock::is_locked(&generated_id_clone).await {
-                            Ok(true) => {
-                                error!("Backup already running for {}", &generated_id_clone);
-                                return;
-                            }
-                            Ok(false) => {
-                                match ctx
-                                    .api
-                                    .backup_create(
-                                        method.clone().to_string(),
-                                        ctx.edge_key.agent_id.clone(),
-                                        &generated_id_clone,
-                                    )
-                                    .await
-                                {
-                                    Ok(backup_created_result) => {
-                                        info!("Backup created successfully");
-                                        let tmp_path = temp_dir.path().to_path_buf();
-                                        info!("Created temp directory {}", tmp_path.display());
-                                        match BackupService::run(db_cfg, &tmp_path).await {
-                                            Ok(mut result) => {
-                                                let backup_id = backup_created_result.unwrap().backup.id;
-
-                                                if result.status == "failed" {
-                                                    error!("Backup failed early for {}", result.generated_id);
-                                                    let service = BackupService { ctx: ctx.clone() };
-                                                    let _ = service
-                                                        .send_result(result, vec![], &backup_id)
-                                                        .await;
-                                                    return;
-                                                }
-
-
-                                                if let Some(backup_file) = result.backup_file.take() {
-                                                    match compress_to_tar_gz_large(&backup_file).await {
-                                                        Ok(compression_result) => {
-                                                            result.backup_file =
-                                                                Some(compression_result.compressed_path);
-                                                            let service = BackupService { ctx: ctx.clone() };
-                                                            match service
-                                                                .upload(
-                                                                    result.clone(),
-                                                                    method,
-                                                                    storages_clone.clone(),
-                                                                    encrypt,
-                                                                    &backup_id,
-                                                                )
-                                                                .await
-                                                            {
-                                                                Ok(upload_result) => {
-                                                                    match service
-                                                                        .send_result(
-                                                                            result,
-                                                                            upload_result,
-                                                                            &backup_id,
-                                                                        )
-                                                                        .await
-                                                                    {
-                                                                        Ok(_) => {
-                                                                            return;
-                                                                        }
-                                                                        Err(e) => {
-                                                                            error!(
-                                                                        "Failed to send backup result: {}",
-                                                                        e
-                                                                    );
-                                                                        }
-                                                                    }
-                                                                }
-                                                                Err(e) => {
-                                                                    error!(
-                                                                "Failed to upload backup files: {}",
-                                                                e
-                                                            );
-                                                                }
-                                                            }
-                                                        }
-                                                        Err(e) => {
-                                                            error!(
-                                                        "Failed to compress backup file : {}",
-                                                        e
-                                                    );
-                                                        }
-                                                    }
-                                                } else {
-                                                    error!("No backup file generated");
-                                                }
-                                            }
-                                            Err(e) => error!("BackupService run failed: {}", e),
-                                        }
-                                        // TempDir is automatically deleted when dropped here
-                                    }
-                                    Err(e) => error!("Backup creation failed: {}", e),
-                                }
-                            }
-                            Err(e) => error!("An error occurred while checking lock : {}", e),
-                        }
-                    }
-                    Err(e) => error!("Failed to create temp dir: {}", e),
-                }
-            });
-        }
-    }
-
-    pub async fn run(cfg: DatabaseConfig, tmp_path: &Path) -> Result<BackupResult> {
-        let db_instance = DatabaseFactory::create_for_backup(cfg.clone()).await;
-        let generated_id = cfg.generated_id.clone();
-        let db_type = cfg.db_type.clone();
-
-
-        let reachable = match db_instance.ping().await {
-            Ok(v) => v,
-            Err(e) => {
-                error!("Ping failed: {}", e);
-                return Err(e.into());
-            }
-        };
-
-
-        info!("Reachable: {}", reachable);
-        if !reachable {
-            return Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "failed".into(),
-                backup_file: None,
-                code: None,
-            });
-        }
-
-        match db_instance.backup(tmp_path).await {
-            Ok(file) => Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "success".into(),
-                backup_file: Some(file),
-                code: None,
-            }),
-            Err(e) => match e.to_string().as_str() {
-                "backup_already_in_progress" => Ok(BackupResult {
-                    generated_id,
-                    db_type,
-                    status: "failed".into(),
-                    backup_file: None,
-                    code: Some(e.to_string()),
-                }),
-                _ => Ok(BackupResult {
-                    generated_id,
-                    db_type,
-                    status: "failed".into(),
-                    backup_file: None,
-                    code: None,
-                }),
-            },
-        }
-    }
-
-    pub async fn upload(
-        &self,
-        result: BackupResult,
-        method: BackupMethod,
-        storages: Vec<DatabaseStorage>,
-        encrypt: bool,
-        backup_id: &String,
-    ) -> Result<Vec<UploadResult>> {
-        if result.code.as_deref() == Some("backup_already_in_progress") {
-            info!("Skipping send: backup already in progress");
-            anyhow::bail!("backup_already_in_progres");
-        }
-
-        let upload_futures = storages.into_iter().map(|storage| {
-            info!(
-                "Uploading storage -> {:?} for {:?}",
-                storage.provider, storage.id
-            );
-            let provider = storage::get_provider(&storage);
-            let result_clone = result.clone();
-            let ctx_clone = self.ctx.clone();
-            let storages_clone = storage.clone();
-            let storage_id = storages_clone.id;
-            let generated_id = result_clone.generated_id.clone();
-
-            async move {
-                match self
-                    .ctx
-                    .api
-                    .backup_upload_init(
-                        self.ctx.edge_key.agent_id.clone(),
-                        generated_id.clone(),
-                        storage_id.clone(),
-                        backup_id,
-                    )
-                    .await
-                {
-                    Ok(upload_init_result) => {
-                        info!("Uploading init result: {:#?}", upload_init_result);
-                        let backup_storage_id = upload_init_result.unwrap().backup_storage.id.clone();
-                        match provider {
-                            Some(provider) => {
-                                let upload_result = provider
-                                    .upload(
-                                        ctx_clone,
-                                        result_clone,
-                                        method,
-                                        &storage,
-                                        Some(encrypt),
-                                    )
-                                    .await;
-
-                                let status = if upload_result.success {
-                                    "success"
-                                } else {
-                                    "failed"
-                                };
-
-                                if status != "success" {
-                                    return upload_result;
-                                }
-
-                                info!("Storage {} uploaded to remote path {:?}", storage_id, upload_result.remote_file_path);
-
-                                let (remote_path, total_size) = match (
-                                    &upload_result.remote_file_path,
-                                    upload_result.total_size,
-                                ) {
-                                    (Some(path), Some(size)) => (path.clone(), size),
-                                    _ => {
-                                        return UploadResult {
-                                            storage_id: storage_id.clone(),
-                                            success: false,
-                                            error: Some("remote_file_path or total_size missing".to_string()),
-                                            remote_file_path: None,
-                                            total_size: None,
-                                        }
-                                    }
-                                };
-
-                                match self.ctx.api.backup_upload_status(
-                                    self.ctx.edge_key.agent_id.clone(),
-                                    generated_id.clone(),
-                                    backup_storage_id,
-                                    status,
-                                    remote_path,
-                                    total_size,
-                                    backup_id,
-                                ).await {
-                                    Ok(_) => {
-                                        upload_result
-                                    }
-                                    Err(err) => {
-                                        error!(
-                                        "backup_upload_status failed (generated_id={}, storage_id={}): {}",
-                                        generated_id, storage_id, err
-                                    );
-                                        UploadResult {
-                                            storage_id: storage_id.clone(),
-                                            success: false,
-                                            error: Some(err.to_string()),
-                                            remote_file_path: None,
-                                            total_size: None,
-                                        }
-                                    }
-                                }
-                            }
-                            None => {
-                                error!("Skipping storage due to missing provider");
-                                UploadResult {
-                                    storage_id: storage_id.clone(),
-                                    success: false,
-                                    error: Some(
-                                        "Skipping storage due to missing provider".to_string(),
-                                    ),
-                                    remote_file_path: None,
-                                    total_size: None,
-                                }
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        error!(
-                            "Unable to create the storage backup on remote server : {}",
-                            e
-                        );
-                        UploadResult {
-                            storage_id: storage_id.clone(),
-                            success: false,
-                            error: Some(
-                                "Unable to create the storage backup on remote server".to_string(),
-                            ),
-                            remote_file_path: None,
-                            total_size: None,
-                        }
-                    }
-                }
-            }
-        });
-
-        let results: Vec<UploadResult> = join_all(upload_futures).await;
-        info!("Upload results: {:#?}", results);
-
-        Ok(results)
-    }
-
-    pub async fn send_result(
-        &self,
-        result: BackupResult,
-        upload_results: Vec<UploadResult>,
-        backup_id: &String,
-    ) -> Result<()> {
-        let status = if upload_results.iter().any(|r| r.success) {
-            "success"
-        } else {
-            "failed"
-        };
-
-        let file_size = if status == "failed" {
-            None
-        } else {
-            let mut sum = 0u64;
-            let mut count = 0u64;
-
-            for size in upload_results.iter().filter_map(|r| r.total_size) {
-                sum += size;
-                count += 1;
-            }
-
-            if count == 0 {
-                None
-            } else {
-                Some(sum / count)
-            }
-        };
-
-        match self
-            .ctx
-            .api
-            .backup_update(self.ctx.edge_key.agent_id.clone(), backup_id, status, file_size, &result.generated_id)
-            .await
-        {
-            Ok(_result) => Ok(()),
-            Err(e) => {
-                error!(
-                    "backup_update failed (generated_id={}, backup_id={}): {}",
-                    &result.generated_id, &backup_id, e
-                );
-                Err(e.into())
-            }
-        }
-    }
-}
@@ -0,0 +1,20 @@
+use super::service::BackupService;
+use crate::utils::compress::compress_to_tar_gz_large;
+use std::path::PathBuf;
+use anyhow::Result;
+
+impl BackupService {
+
+    pub async fn compress_backup(
+        &self,
+        backup_file: Option<PathBuf>,
+    ) -> Result<PathBuf> {
+
+        let file = backup_file
+            .ok_or_else(|| anyhow::anyhow!("No backup file generated"))?;
+
+        let compression = compress_to_tar_gz_large(&file).await?;
+
+        Ok(compression.compressed_path)
+    }
+}
@@ -0,0 +1,44 @@
+use super::service::BackupService;
+use crate::services::config::DatabasesConfig;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::utils::common::BackupMethod;
+use tracing::error;
+
+impl BackupService {
+
+    pub async fn dispatch(
+        &self,
+        generated_id: &String,
+        config: &DatabasesConfig,
+        method: BackupMethod,
+        storages: &Vec<DatabaseStorage>,
+        encrypt: bool,
+    ) {
+
+        let Some(cfg) = config
+            .databases
+            .iter()
+            .find(|c| c.generated_id == generated_id.as_str())
+        else {
+            error!("Database config not found for {}", generated_id);
+            return;
+        };
+
+        let service = Self {
+            ctx: self.ctx.clone(),
+        };
+
+        let db_cfg = cfg.clone();
+        let storages = storages.clone();
+        let generated_id = generated_id.clone();
+
+        tokio::spawn(async move {
+            if let Err(e) = service
+                .execute_backup(generated_id, db_cfg, method, storages, encrypt)
+                .await
+            {
+                error!("Backup execution failed: {}", e);
+            }
+        });
+    }
+}
@@ -0,0 +1,49 @@
+use super::service::BackupService;
+use crate::services::config::DatabaseConfig;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::utils::common::BackupMethod;
+use crate::utils::locks::FileLock;
+
+use tempfile::TempDir;
+use anyhow::Result;
+
+impl BackupService {
+
+    pub async fn execute_backup(
+        &self,
+        generated_id: String,
+        db_cfg: DatabaseConfig,
+        method: BackupMethod,
+        storages: Vec<DatabaseStorage>,
+        encrypt: bool,
+    ) -> Result<()> {
+
+        if FileLock::is_locked(&generated_id).await? {
+            anyhow::bail!("backup already running");
+        }
+        
+        let backup = self.create_backup_record(&generated_id, &method).await?;
+        let backup_id = backup.backup.id;
+
+        let temp_dir = TempDir::new()?;
+        let tmp_path = temp_dir.path();
+
+        let mut result = Self::run(db_cfg, tmp_path).await?;
+
+        if result.status == "failed" {
+            self.send_result(result, vec![], &backup_id).await?;
+            return Ok(());
+        }
+
+        let compressed = self.compress_backup(result.backup_file.take()).await?;
+        result.backup_file = Some(compressed);
+
+        let uploads = self
+            .upload(result.clone(), method, storages, encrypt, &backup_id)
+            .await?;
+
+        self.send_result(result, uploads, &backup_id).await?;
+
+        Ok(())
+    }
+}
@@ -0,0 +1,26 @@
+use super::service::BackupService;
+use crate::utils::common::BackupMethod;
+use anyhow::{Result, anyhow};
+use crate::services::api::models::agent::backup::BackupResponse;
+
+impl BackupService {
+
+    pub async fn create_backup_record(
+        &self,
+        generated_id: &str,
+        method: &BackupMethod,
+    ) -> Result<BackupResponse> {
+
+        let response = self
+            .ctx
+            .api
+            .backup_create(
+                method.to_string(),
+                self.ctx.edge_key.agent_id.clone(),
+                generated_id,
+            )
+            .await?;
+
+        response.ok_or_else(|| anyhow!("backup_create returned empty response"))
+    }
+}
@@ -0,0 +1,11 @@
+pub mod service;
+pub mod dispatcher;
+pub mod executor;
+pub mod compressor;
+pub mod uploader;
+pub mod result;
+pub mod models;
+pub mod helpers;
+pub mod runner;
+
+pub use service::BackupService;
@@ -0,0 +1,22 @@
+#![allow(dead_code)]
+
+use std::path::PathBuf;
+use crate::services::config::DbType;
+
+#[derive(Debug, Clone)]
+pub struct BackupResult {
+    pub generated_id: String,
+    pub db_type: DbType,
+    pub status: String,
+    pub backup_file: Option<PathBuf>,
+    pub code: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct UploadResult {
+    pub storage_id: String,
+    pub success: bool,
+    pub error: Option<String>,
+    pub remote_file_path: Option<String>,
+    pub total_size: Option<u64>,
+}
@@ -0,0 +1,45 @@
+use super::models::{BackupResult, UploadResult};
+use super::service::BackupService;
+use crate::services::api::ApiError;
+use crate::services::api::models::agent::backup::BackupResponse;
+use anyhow::Result;
+use tracing::error;
+
+impl BackupService {
+    pub async fn send_result(
+        &self,
+        result: BackupResult,
+        upload_results: Vec<UploadResult>,
+        backup_id: &String,
+    ) -> Result<Option<BackupResponse>, ApiError> {
+        let status = if upload_results.iter().any(|r| r.success) {
+            "success"
+        } else {
+            "failed"
+        };
+
+        let file_size = upload_results
+            .iter()
+            .filter_map(|r| r.total_size)
+            .reduce(|a, b| a + b)
+            .map(|sum| sum / upload_results.len() as u64);
+
+        self.ctx
+            .api
+            .backup_update(
+                self.ctx.edge_key.agent_id.clone(),
+                backup_id,
+                status,
+                file_size,
+                &result.generated_id,
+            )
+            .await
+            .map_err(|e| {
+                error!(
+                    "backup_update failed (generated_id={}, backup_id={}): {}",
+                    result.generated_id, backup_id, e
+                );
+                e.into()
+            })
+    }
+}
@@ -0,0 +1,70 @@
+use super::models::BackupResult;
+use super::service::BackupService;
+
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::DatabaseConfig;
+
+use anyhow::Result;
+use std::path::Path;
+use tracing::{error, info};
+
+impl BackupService {
+
+    pub async fn run(
+        cfg: DatabaseConfig,
+        tmp_path: &Path,
+    ) -> Result<BackupResult> {
+
+        let db = DatabaseFactory::create_for_backup(cfg.clone()).await;
+
+        let generated_id = cfg.generated_id.clone();
+        let db_type = cfg.db_type.clone();
+
+        let reachable = match db.ping().await {
+            Ok(v) => v,
+            Err(e) => {
+                error!("Ping failed: {}", e);
+                return Err(e.into());
+            }
+        };
+
+        info!("Reachable: {}", reachable);
+
+        if !reachable {
+            return Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "failed".into(),
+                backup_file: None,
+                code: None,
+            });
+        }
+
+        match db.backup(tmp_path).await {
+
+            Ok(file) => Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "success".into(),
+                backup_file: Some(file),
+                code: None,
+            }),
+
+            Err(e) if e.to_string() == "backup_already_in_progress" => Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "failed".into(),
+                backup_file: None,
+                code: Some("backup_already_in_progress".into()),
+            }),
+
+            Err(_) => Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "failed".into(),
+                backup_file: None,
+                code: None,
+            }),
+        }
+    }
+}
@@ -0,0 +1,12 @@
+use std::sync::Arc;
+use crate::core::context::Context as CoreContext;
+
+pub struct BackupService {
+    pub ctx: Arc<CoreContext>,
+}
+
+impl BackupService {
+    pub fn new(ctx: Arc<CoreContext>) -> Self {
+        Self { ctx }
+    }
+}
@@ -0,0 +1,181 @@
+use super::service::BackupService;
+use super::models::{BackupResult, UploadResult};
+
+use crate::services::storage;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::utils::common::BackupMethod;
+
+use futures::future::join_all;
+use anyhow::{Result, bail};
+use tracing::{info, error};
+
+impl BackupService {
+
+    pub async fn upload(
+        &self,
+        result: BackupResult,
+        method: BackupMethod,
+        storages: Vec<DatabaseStorage>,
+        encrypt: bool,
+        backup_id: &String,
+    ) -> Result<Vec<UploadResult>> {
+
+        if result.code.as_deref() == Some("backup_already_in_progress") {
+            info!("Skipping send: backup already in progress");
+            bail!("backup_already_in_progress");
+        }
+
+        let ctx = self.ctx.clone();
+
+        let futures = storages.into_iter().map(|storage| {
+
+            let ctx_clone = ctx.clone();
+            let result_clone = result.clone();
+            let provider = storage::get_provider(&storage);
+
+            let storage_id = storage.id.clone();
+            let generated_id = result_clone.generated_id.clone();
+
+            async move {
+
+                info!("Uploading storage -> {:?} for {:?}", storage.provider, storage_id);
+
+                /*
+                 INIT STEP
+                */
+                let init = match ctx_clone.api
+                    .backup_upload_init(
+                        ctx_clone.edge_key.agent_id.clone(),
+                        generated_id.clone(),
+                        storage_id.clone(),
+                        backup_id,
+                    )
+                    .await
+                {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("backup_upload_init failed: {}", e);
+
+                        return UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some("backup_upload_init failed".into()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                };
+
+                let backup_storage_id = match init {
+                    Some(v) => v.backup_storage.id,
+                    None => {
+                        return UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some("backup_upload_init returned empty response".into()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                };
+
+                /*
+                 PROVIDER CHECK
+                */
+                let Some(provider) = provider else {
+                    error!("Skipping storage due to missing provider");
+
+                    return UploadResult {
+                        storage_id,
+                        success: false,
+                        error: Some("missing provider".into()),
+                        remote_file_path: None,
+                        total_size: None,
+                    };
+                };
+
+                /*
+                 STORAGE UPLOAD
+                */
+                let upload_result = provider
+                    .upload(
+                        ctx_clone.clone(),
+                        result_clone,
+                        method,
+                        &storage,
+                        Some(encrypt),
+                    )
+                    .await;
+
+                let status = if upload_result.success { "success" } else { "failed" };
+
+                if status != "success" {
+                    return upload_result;
+                }
+
+                info!(
+                    "Storage {} uploaded to remote path {:?}",
+                    storage_id,
+                    upload_result.remote_file_path
+                );
+
+                /*
+                 METADATA VALIDATION
+                */
+                let (remote_path, total_size) = match (
+                    &upload_result.remote_file_path,
+                    upload_result.total_size,
+                ) {
+                    (Some(path), Some(size)) => (path.clone(), size),
+                    _ => {
+                        return UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some("remote_file_path or total_size missing".into()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                };
+
+                /*
+                 STATUS UPDATE
+                */
+                match ctx_clone.api.backup_upload_status(
+                    ctx_clone.edge_key.agent_id.clone(),
+                    generated_id,
+                    backup_storage_id,
+                    status,
+                    remote_path,
+                    total_size,
+                    backup_id,
+                ).await {
+
+                    Ok(_) => upload_result,
+
+                    Err(err) => {
+                        error!(
+                            "backup_upload_status failed (storage_id={}): {}",
+                            storage_id,
+                            err
+                        );
+
+                        UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some(err.to_string()),
+                            remote_file_path: None,
+                            total_size: None,
+                        }
+                    }
+                }
+            }
+        });
+
+        let results: Vec<UploadResult> = join_all(futures).await;
+
+        info!("Upload results: {:#?}", results);
+
+        Ok(results)
+    }
+}
@@ -9,6 +9,7 @@ use std::path::Path;
 use std::sync::Arc;
 use toml;
 use tracing::info;
+use uuid::Uuid;

 #[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "lowercase")]
@@ -16,8 +17,8 @@ pub enum DbType {
    Mysql,
    Mariadb,
    Postgresql,
-    MongoDB
-    // Sqlite,
+    MongoDB,
+    Sqlite,
    // Add other DB types if needed
 }

@@ -28,7 +29,7 @@ impl DbType {
            DbType::Mariadb => "mysql",
            DbType::Postgresql => "postgresql",
            DbType::MongoDB => "mongodb",
-            // DbType::Sqlite => "sqlite",
+            DbType::Sqlite => "sqlite",
        }
    }
 }
@@ -45,6 +46,7 @@ pub struct DatabaseConfig {
    pub port: u16,
    pub host: String,
    pub generated_id: String,
+    pub path: String,
 }

 #[allow(dead_code)]
@@ -53,6 +55,29 @@ pub struct DatabasesConfig {
    pub databases: Vec<DatabaseConfig>,
 }

+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize, Clone)]
+pub struct InputDatabaseConfig {
+    pub name: String,
+    pub database: Option<String>,
+    #[serde(rename = "type")]
+    pub db_type: DbType,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub port: Option<u16>,
+    pub host: Option<String>,
+    pub generated_id: String,
+    pub path: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize, Clone)]
+pub struct InputDatabasesConfig {
+    pub databases: Vec<InputDatabaseConfig>,
+}
+
+
 pub struct ConfigService {
    ctx: Arc<Context>,
 }
@@ -95,7 +120,7 @@ impl ConfigService {
        file.read_to_string(&mut contents)
            .map_err(|e| format!("Failed to read config file: {}", e))?;

-        let config: DatabasesConfig = match extension {
+        let input_config: InputDatabasesConfig = match extension {
            "json" => {
                serde_json::from_str(&contents).map_err(|e| format!("JSON parsing error: {}", e))?
            }
@@ -105,8 +130,71 @@ impl ConfigService {
            _ => return Err("Unsupported config file format. Use .json or .toml".to_string()),
        };

-        info!("Databases : {:?} instances loaded", config.databases.len());
+        fn required<T: Clone>(opt: &Option<T>, db_name: &str, field_name: &str) -> Result<T, String> {
+            match opt {
+                Some(v) => Ok(v.clone()),
+                None => {
+                    let msg = format!("Missing required field '{}' for database '{}'", field_name, db_name);
+                    Err(msg)
+                }
+            }
+        }

-        Ok(config)
+        fn optional<T: Clone>(opt: &Option<T>) -> T where T: Default {
+            opt.clone().unwrap_or_default()
+        }
+
+        let mut databases = Vec::with_capacity(input_config.databases.len());
+
+        for db in input_config.databases {
+            if Uuid::parse_str(&db.generated_id).is_err() {
+                return Err(format!("Invalid UUID for database '{}'", db.name));
+            }
+
+            let username = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => required(&db.username, &db.name, "username")?,
+                _ => optional(&db.username),
+            };
+
+            let password = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => required(&db.password, &db.name, "password")?,
+                _ => optional(&db.password),
+            };
+
+            let host = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB => required(&db.host, &db.name, "host")?,
+                DbType::Sqlite => optional(&db.host),
+            };
+
+            let port = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB => required(&db.port, &db.name, "port")?,
+                DbType::Sqlite => db.port.unwrap_or(0),
+            };
+
+            let database_name = match db.db_type {
+                DbType::Sqlite => optional(&db.database),
+                _ => required(&db.database, &db.name, "database")?
+            };
+
+            let path_val = match db.db_type {
+                DbType::Sqlite => required(&db.path, &db.name, "path")?,
+                _ => optional(&db.path),
+            };
+
+            databases.push(DatabaseConfig {
+                name: db.name,
+                database: database_name,
+                db_type: db.db_type,
+                username,
+                password,
+                host,
+                port,
+                generated_id: db.generated_id,
+                path: path_val,
+            });
+        }
+
+        info!("Databases: {} instances loaded", databases.len());
+        Ok(DatabasesConfig { databases })
    }
 }
@@ -1,246 +0,0 @@
-#![allow(dead_code)]
-#![warn(unused_assignments)]
-use crate::core::context::Context;
-use crate::domain::factory::DatabaseFactory;
-use crate::services::api::models::agent::status::DatabaseStatus;
-use crate::services::config::{DatabaseConfig, DatabasesConfig};
-use crate::utils::compress::decompress_large_tar_gz;
-use crate::utils::file::decrypt_file_stream_gcm;
-use anyhow::Result;
-use reqwest::{Client, Url};
-use serde::Serialize;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use tempfile::TempDir;
-use tracing::{error, info};
-
-#[derive(Debug, Serialize)]
-pub struct RestoreResult {
-    #[serde(rename = "generatedId")]
-    pub generated_id: String,
-    pub status: String,
-}
-
-pub struct RestoreService {
-    ctx: Arc<Context>,
-}
-
-impl RestoreService {
-    pub fn new(ctx: Arc<Context>) -> Self {
-        Self { ctx }
-    }
-
-    pub async fn dispatch(&self, db: &DatabaseStatus, config: &DatabasesConfig) {
-        if let Some(cfg) = config
-            .databases
-            .iter()
-            .find(|c| c.generated_id == db.generated_id)
-        {
-            let db_cfg = cfg.clone();
-            let ctx_clone = self.ctx.clone();
-            let file_to_restore = db.data.restore.file.clone();
-            if file_to_restore.is_none() {
-                error!("restore file not found");
-                return;
-            }
-            tokio::spawn(async move {
-                match TempDir::new() {
-                    Ok(temp_dir) => {
-                        let tmp_path = temp_dir.path().to_path_buf();
-                        info!("Created temp directory {}", tmp_path.display());
-                        match RestoreService::run(
-                            &ctx_clone,
-                            db_cfg,
-                            &tmp_path,
-                            &file_to_restore.unwrap(),
-                        )
-                        .await
-                        {
-                            Ok(result) => {
-                                let service = RestoreService { ctx: ctx_clone };
-                                service.send_result(result).await;
-                            }
-                            Err(e) => error!("Restoration error {}", e),
-                        }
-                        // TempDir is automatically deleted when dropped
-                    }
-                    Err(e) => error!("Failed to create temp dir: {}", e),
-                }
-            });
-        }
-    }
-
-    pub async fn run(
-        ctx: &Arc<Context>,
-        cfg: DatabaseConfig,
-        tmp_path: &Path,
-        file_url: &str,
-    ) -> Result<RestoreResult> {
-        let generated_id = cfg.generated_id.clone();
-
-        info!("File url: {}", file_url);
-
-        let client = Client::new();
-        let response = client.get(file_url).send().await?;
-
-        if !response.status().is_success() {
-            error!("Backup download failed with status {}", response.status());
-            return Ok(RestoreResult {
-                generated_id,
-                status: "failed".into(),
-            });
-        }
-
-        let filename_from_header = response
-            .headers()
-            .get(reqwest::header::CONTENT_DISPOSITION)
-            .and_then(|v| v.to_str().ok())
-            .and_then(|s| s.split("filename=").nth(1))
-            .map(|f| f.trim_matches('"').to_string());
-
-        let filename_from_url = Url::parse(file_url).ok().and_then(|u| {
-            u.path_segments()?
-                .last()
-                .filter(|s| !s.is_empty())
-                .map(|s| s.to_string())
-        });
-
-        let filename = filename_from_header
-            .or(filename_from_url)
-            .unwrap_or_else(|| "downloaded_file".to_string());
-
-        info!("File name: {}", filename);
-
-        let bytes = response.bytes().await?;
-
-        let is_legacy_file = if filename.ends_with(".sql") {
-            true
-        } else if filename.ends_with(".dump") {
-            true
-        } else {
-            false
-        };
-        let downloaded_file = tmp_path.join(&filename);
-        tokio::fs::write(&downloaded_file, &bytes).await?;
-        info!("Backup downloaded to {}", downloaded_file.display());
-
-        let backup_file_path: PathBuf = if !is_legacy_file {
-            let encrypted = if filename.ends_with(".tar.gz") {
-                false
-            } else if filename.ends_with(".tar.gz.enc") {
-                true
-            } else {
-                return Ok(RestoreResult {
-                    generated_id,
-                    status: "failed".into(),
-                });
-            };
-
-            info!("Encrypted: {}", encrypted);
-
-            let mut compressed_archive = downloaded_file.clone();
-
-            if encrypted {
-                let new_name = downloaded_file
-                    .file_name()
-                    .and_then(|n| n.to_str())
-                    .and_then(|n| n.strip_suffix(".enc"))
-                    .ok_or_else(|| anyhow::anyhow!("Invalid encrypted filename"))?;
-
-                let new_compressed_archive = tmp_path.join(new_name);
-
-                decrypt_file_stream_gcm(
-                    downloaded_file,
-                    new_compressed_archive.clone(),
-                    ctx.edge_key.master_key_b64.clone(),
-                )
-                .await
-                .map_err(|e| {
-                    error!("Failed to decrypt file: {}", e);
-                    e
-                })?;
-
-                compressed_archive = new_compressed_archive;
-            }
-
-            let decompressed_files =
-                decompress_large_tar_gz(compressed_archive.as_path(), tmp_path).await?;
-
-            if decompressed_files.is_empty() {
-                return Ok(RestoreResult {
-                    generated_id,
-                    status: "failed".into(),
-                });
-            }
-
-            if decompressed_files.len() == 1 {
-                decompressed_files[0].clone()
-            } else {
-                compressed_archive
-            }
-        } else {
-            downloaded_file.clone()
-        };
-
-        let db_instance = DatabaseFactory::create_for_restore(cfg.clone(), &backup_file_path).await;
-        let reachable = db_instance.ping().await.unwrap_or(false);
-        info!("Reachable: {}", reachable);
-        if !reachable {
-            return Ok(RestoreResult {
-                generated_id,
-                status: "failed".into(),
-            });
-        }
-
-        match db_instance.restore(&backup_file_path).await {
-            Ok(_) => Ok(RestoreResult {
-                generated_id,
-                status: "success".into(),
-            }),
-            Err(e) => {
-                error!("Restore failed: {:?}", e);
-                Ok(RestoreResult {
-                    generated_id,
-                    status: "failed".into(),
-                })
-            }
-        }
-    }
-
-    // TODO : update with ctx api manager
-    pub async fn send_result(&self, result: RestoreResult) {
-        info!(
-            "[RestoreService] DB: {} | Status: {}",
-            result.generated_id, result.status,
-        );
-
-        let client = reqwest::Client::new();
-        let url = format!(
-            "{}/api/agent/{}/restore",
-            self.ctx.edge_key.server_url, self.ctx.edge_key.agent_id
-        );
-
-        let body = RestoreResult {
-            generated_id: result.generated_id,
-            status: result.status,
-        };
-
-        match client.post(&url).json(&body).send().await {
-            Ok(resp) => {
-                let status = resp.status();
-                if status.is_success() {
-                    info!("Restoration result sent successfully");
-                } else {
-                    let text = resp.text().await.unwrap_or_default();
-                    error!(
-                        "Restoration result failed, status: {}, body: {}",
-                        status, text
-                    );
-                }
-            }
-            Err(e) => {
-                error!("Failed to send restoration result: {}", e);
-            }
-        }
-    }
-}
@@ -0,0 +1,61 @@
+use super::service::RestoreService;
+
+use crate::utils::compress::decompress_large_tar_gz;
+use crate::utils::file::decrypt_file_stream_gcm;
+
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+
+impl RestoreService {
+
+    pub async fn prepare_archive(
+        &self,
+        downloaded_file: PathBuf,
+        tmp_path: &Path,
+    ) -> Result<PathBuf> {
+
+        let filename = downloaded_file
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .to_string();
+
+        let is_legacy = filename.ends_with(".sql") || filename.ends_with(".dump");
+
+        if is_legacy {
+            return Ok(downloaded_file);
+        }
+
+        let encrypted = filename.ends_with(".tar.gz.enc");
+
+        let mut archive = downloaded_file.clone();
+
+        if encrypted {
+
+            let new_name = filename.strip_suffix(".enc").unwrap();
+
+            let decrypted = tmp_path.join(new_name);
+
+            decrypt_file_stream_gcm(
+                downloaded_file,
+                decrypted.clone(),
+                self.ctx.edge_key.master_key_b64.clone(),
+            )
+                .await?;
+
+            archive = decrypted;
+        }
+
+        let files = decompress_large_tar_gz(archive.as_path(), tmp_path).await?;
+
+        if files.is_empty() {
+            anyhow::bail!("archive empty");
+        }
+
+        if files.len() == 1 {
+            Ok(files[0].clone())
+        } else {
+            Ok(archive)
+        }
+    }
+}
@@ -0,0 +1,42 @@
+use super::service::RestoreService;
+use crate::services::config::DatabasesConfig;
+use crate::services::api::models::agent::status::DatabaseStatus;
+
+use tracing::error;
+
+impl RestoreService {
+
+    pub async fn dispatch(&self, db: &DatabaseStatus, config: &DatabasesConfig) {
+
+        let Some(cfg) = config
+            .databases
+            .iter()
+            .find(|c| c.generated_id == db.generated_id)
+        else {
+            error!("Database config not found");
+            return;
+        };
+
+        let Some(file_to_restore) = db.data.restore.file.clone() else {
+            error!("restore file not found");
+            return;
+        };
+
+        let service = Self {
+            ctx: self.ctx.clone(),
+        };
+
+        let db_cfg = cfg.clone();
+
+        tokio::spawn(async move {
+
+            if let Err(e) = service
+                .execute_restore(db_cfg, file_to_restore)
+                .await
+            {
+                error!("Restore failed: {}", e);
+            }
+
+        });
+    }
+}
@@ -0,0 +1,53 @@
+use super::service::RestoreService;
+
+use reqwest::{Client, Url};
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+use tracing::info;
+
+impl RestoreService {
+
+    pub async fn download_backup(
+        &self,
+        file_url: &str,
+        tmp_path: &Path,
+    ) -> Result<PathBuf> {
+
+        let client = Client::new();
+
+        let response = client.get(file_url).send().await?;
+
+        if !response.status().is_success() {
+            anyhow::bail!("download failed");
+        }
+
+        let filename_from_header = response
+            .headers()
+            .get(reqwest::header::CONTENT_DISPOSITION)
+            .and_then(|v| v.to_str().ok())
+            .and_then(|s| s.split("filename=").nth(1))
+            .map(|f| f.trim_matches('"').to_string());
+
+
+        let filename_from_url = Url::parse(file_url).ok().and_then(|u| {
+            u.path_segments()?
+                .last()
+                .filter(|s| !s.is_empty())
+                .map(|s| s.to_string())
+        });
+
+        let filename = filename_from_header
+            .or(filename_from_url)
+            .unwrap_or_else(|| "downloaded_file".to_string());
+
+        let path = tmp_path.join(&filename);
+
+        let bytes = response.bytes().await?;
+
+        tokio::fs::write(&path, &bytes).await?;
+
+        info!("Backup downloaded to {}", path.display());
+
+        Ok(path)
+    }
+}
@@ -0,0 +1,30 @@
+use super::service::RestoreService;
+use crate::services::config::DatabaseConfig;
+use tempfile::TempDir;
+use anyhow::Result;
+use tracing::info;
+
+impl RestoreService {
+
+    pub async fn execute_restore(
+        &self,
+        cfg: DatabaseConfig,
+        file_url: String,
+    ) -> Result<()> {
+
+        let temp_dir = TempDir::new()?;
+        let tmp_path = temp_dir.path();
+
+        info!("Created temp directory {}", tmp_path.display());
+
+        let downloaded = self.download_backup(&file_url, tmp_path).await?;
+
+        let backup_file = self.prepare_archive(downloaded, tmp_path).await?;
+
+        let result = self.run_restore(cfg, backup_file).await?;
+
+        self.send_result(result).await;
+
+        Ok(())
+    }
+}
@@ -0,0 +1,10 @@
+pub mod service;
+pub mod dispatcher;
+pub mod executor;
+pub mod downloader;
+pub mod archive;
+pub mod runner;
+pub mod result;
+pub mod models;
+
+pub use service::RestoreService;
@@ -0,0 +1,8 @@
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct RestoreResult {
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    pub status: String,
+}
@@ -0,0 +1,30 @@
+use super::service::RestoreService;
+use super::models::RestoreResult;
+
+use tracing::{info, error};
+
+impl RestoreService {
+    pub async fn send_result(&self, result: RestoreResult) {
+
+        info!(
+            "[RestoreService] DB: {} | Status: {}",
+            result.generated_id, result.status
+        );
+
+        match self.ctx
+            .api
+            .restore_result(
+                self.ctx.edge_key.agent_id.clone(),
+                &result.generated_id,
+                &result.status,
+            )
+            .await {
+            Ok(_) => {
+                info!("Restoration result sent successfully");
+            }
+            Err(e) => {
+                error!("Failed to send restoration result: {}", e);
+            }
+        }
+    }
+}
@@ -0,0 +1,51 @@
+use super::service::RestoreService;
+use super::models::RestoreResult;
+
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::DatabaseConfig;
+
+use anyhow::Result;
+use std::path::PathBuf;
+use tracing::{info, error};
+
+impl RestoreService {
+
+    pub async fn run_restore(
+        &self,
+        cfg: DatabaseConfig,
+        backup_file: PathBuf,
+    ) -> Result<RestoreResult> {
+
+        let generated_id = cfg.generated_id.clone();
+
+        let db = DatabaseFactory::create_for_restore(cfg.clone(), &backup_file).await;
+
+        let reachable = db.ping().await.unwrap_or(false);
+
+        info!("Reachable: {}", reachable);
+
+        if !reachable {
+            return Ok(RestoreResult {
+                generated_id,
+                status: "failed".into(),
+            });
+        }
+
+        match db.restore(&backup_file).await {
+
+            Ok(_) => Ok(RestoreResult {
+                generated_id,
+                status: "success".into(),
+            }),
+
+            Err(e) => {
+                error!("Restore failed: {:?}", e);
+
+                Ok(RestoreResult {
+                    generated_id,
+                    status: "failed".into(),
+                })
+            }
+        }
+    }
+}
@@ -0,0 +1,12 @@
+use std::sync::Arc;
+use crate::core::context::Context;
+
+pub struct RestoreService {
+    pub ctx: Arc<Context>,
+}
+
+impl RestoreService {
+    pub fn new(ctx: Arc<Context>) -> Self {
+        Self { ctx }
+    }
+}
@@ -1,7 +1,6 @@
 pub mod providers;

 use crate::core::context::Context;
-use crate::services::backup::{BackupResult, UploadResult};
 use crate::utils::common::BackupMethod;
 use async_trait::async_trait;
 use providers::local;
@@ -10,6 +9,7 @@ use providers::google_drive;
 use std::sync::Arc;
 use tracing::{error, info};
 use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::backup::models::{BackupResult, UploadResult};

 #[async_trait]
 pub trait StorageProvider: Send + Sync {
@@ -3,7 +3,6 @@ mod models;

 use crate::core::context::Context;
 use crate::services::api::models::agent::status::DatabaseStorage;
-use crate::services::backup::{BackupResult, UploadResult};
 use crate::services::storage::StorageProvider;
 use crate::utils::common::BackupMethod;
 use crate::utils::file::{full_file_name, full_file_path};
@@ -12,6 +11,7 @@ use async_trait::async_trait;
 use std::sync::Arc;
 use tokio::fs;
 use tracing::{error, info};
+use crate::services::backup::models::{BackupResult, UploadResult};
 use crate::services::storage::providers::google_drive::helpers::{upload_stream_to_google_drive};
 use crate::services::storage::providers::google_drive::models::GoogleDriveProviderConfig;

@@ -1,6 +1,5 @@
 use crate::core::context::Context;
 use crate::services::api::models::agent::status::DatabaseStorage;
-use crate::services::backup::{BackupResult, UploadResult};
 use crate::services::storage::StorageProvider;
 use crate::utils::common::BackupMethod;
 use crate::utils::file::{full_file_name, full_file_path};
@@ -11,6 +10,7 @@ use reqwest::header::{HeaderMap, HeaderValue};
 use std::sync::Arc;
 use tokio::fs;
 use tracing::error;
+use crate::services::backup::models::{BackupResult, UploadResult};

 pub struct LocalProvider;

@@ -2,7 +2,6 @@ mod models;

 use crate::core::context::Context;
 use crate::services::api::models::agent::status::DatabaseStorage;
-use crate::services::backup::{BackupResult, UploadResult};
 use crate::services::storage::StorageProvider;
 use crate::services::storage::providers::s3::models::S3ProviderConfig;
 use crate::utils::common::BackupMethod;
@@ -19,6 +18,7 @@ use std::pin::Pin;
 use std::sync::Arc;
 use tokio::fs;
 use tracing::{error, info};
+use crate::services::backup::models::{BackupResult, UploadResult};

 pub struct S3Provider {}

@@ -94,12 +94,15 @@ impl StorageProvider for S3Provider {
        );

        let region = Region::new(config.region.clone().unwrap_or("us-east-1".to_string()));
-
-        let scheme = if config.ssl { "https" } else { "http" };
-
-        let endpoint = match config.port {
-            Some(port) => format!("{scheme}://{}:{port}", config.end_point_url),
-            None => format!("{scheme}://{}", config.end_point_url),
+        
+        let endpoint = if let Some(port) = &config.port {
+            if port.trim().is_empty() {
+                format!("{}://{}", if config.ssl { "https" } else { "http" }, config.end_point_url)
+            } else {
+                format!("{}://{}:{}", if config.ssl { "https" } else { "http" }, config.end_point_url, port)
+            }
+        } else {
+            format!("{}://{}", if config.ssl { "https" } else { "http" }, config.end_point_url)
        };

        info!("S3 endpoint to {}", &endpoint);
Author	SHA1	Message	Date
github-actions[bot]	189ad866de	chore: release 1.2.5	2026-03-08 20:50:53 +00:00
Charles GTE	55bbd4e724	fix: new-workflow-ci (#32 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 21:48:13 +01:00
github-actions[bot]	4f67a57681	chore: release 1.2.4	2026-03-08 20:20:58 +00:00
Charles GTE	45a1118f64	fix: docker build (#31 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 21:18:27 +01:00
github-actions[bot]	f2275d5aca	chore: release 1.2.3	2026-03-08 20:00:47 +00:00
Charles GTE	b136140b55	fix: new-workflow-ci (#30 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * fix: docker.yml * fix: docker.yml * fix: docker.yml * fix: docker.yml --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:58:19 +01:00
github-actions[bot]	773077f66b	chore: release 1.2.2	2026-03-08 19:48:25 +00:00
Charles GTE	46ff086cf9	fix: new-workflow-ci (#29 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * fix: docker.yml * fix: docker.yml --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:47:41 +01:00
github-actions[bot]	f563c187db	chore: release 1.2.1	2026-03-08 19:43:01 +00:00
Charles GTE	df0dffa47b	fix: new-workflow-ci (#28 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:42:16 +01:00
github-actions[bot]	864396422b	chore: release 1.2.0	2026-03-08 19:38:10 +00:00
Charles GTE	e280c1d2f8	fix: workflow (#27 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:31:41 +01:00
Charles GTE	91a9d0654b	feat: new workflow CI (#26 ) * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI * feat: new workflow CI --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:28:26 +01:00
Charles GTE	bc857a4c18	feat: new workflow CI * feat: new workflow CI * feat: new workflow CI --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:24:26 +01:00
Charles GTE	2454915866	feat: new workflow CI (#24 ) Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 20:22:45 +01:00
Charles GTE	a4a7a9a2c4	feat: new workflow CI feat: new workflow CI	2026-03-08 20:12:43 +01:00
charlesgauthereau	997ba2afa2	feat: new workflow CI	2026-03-08 20:12:00 +01:00
Charles GTE	f973bc1f52	fix: refactoring for backup and restore service * fix: docker-compose.yml * fix: refactoring for backup and restore service * fix: cargo update * fix: refactoring of the backup and restore services --------- Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-08 19:47:04 +01:00
Charles GTE	6ea9fdf8bc	Merge pull request #21 from Portabase/dev chore: add coderabbitai config file	2026-03-05 11:21:45 +01:00
Charles GTE	ad68be8a5a	fix: coderrabbit.yaml	2026-03-05 11:19:47 +01:00
Charles GTE	434c131afb	chore: add coderabbitai config file	2026-03-05 11:10:20 +01:00
Charles GTE	675ac5976d	Merge pull request #20 from Portabase/dev chore: add trailing newlines to README.md	2026-03-05 10:59:26 +01:00
Charles GTE	70543fe032	fix: README.md	2026-03-05 10:45:55 +01:00
Charles GTE	77f90308b4	Update README.md	2026-03-02 08:46:32 +01:00
charlesgauthereau	63cb254abd	chore: Cargo.lock	2026-02-24 08:45:50 +01:00
charlesgauthereau	7738745def	chore(release): 1.1.6	2026-02-24 08:45:26 +01:00
charlesgauthereau	82659f681c	feat: add local test db for sqlite	2026-02-23 22:44:57 +01:00
charlesgauthereau	eee3bebd50	feat: add local test db for sqlite	2026-02-23 22:43:44 +01:00
charlesgauthereau	58dd0259f9	chore(release): 1.1.6-rc.1	2026-02-23 21:55:47 +01:00
Charles GTE	5b7453208b	Merge pull request #16 from Portabase/feat/sqlite feat/sqlite	2026-02-23 21:54:04 +01:00
charlesgauthereau	35933aae52	fix: refactoring config check on startup agent.	2026-02-23 21:47:18 +01:00
charlesgauthereau	178628cb1c	feat: add sqlite support, first working version	2026-02-22 21:46:16 +01:00
charlesgauthereau	3fc60e3f40	fix: s3 provider port config.	2026-02-19 21:16:13 +01:00