Merge #3182

3182: Bump the other milli r=curquiza a=Kerollmops

This PR bumps the other import of milli in the TOML.

Co-authored-by: Clément Renault <clement@meilisearch.com>

.github/ISSUE_TEMPLATE/config.yml

@@ -1,13 +1,13 @@
 contact_links:
-  - name: Support questions & other
-    url: https://github.com/meilisearch/meilisearch/discussions/new
-    about: For any other question, open a discussion in this repository
   - name: Language support request & feedback
     url: https://github.com/meilisearch/product/discussions/categories/feedback-feature-proposal?discussions_q=label%3Aproduct%3Acore%3Atokenizer+category%3A%22Feedback+%26+Feature+Proposal%22
     about:  The requests and feedback regarding Language support are not managed in this repository. Please upvote the related discussion in our dedicated product repository or open a new one if it doesn't exist.
-  - name: Any other feature request & feedback
+  - name: Feature request & feedback
     url: https://github.com/meilisearch/product/discussions/categories/feedback-feature-proposal
     about: The feature requests and feedback regarding the already existing features are not managed in this repository. Please open a discussion in our dedicated product repository
   - name: Documentation issue
     url: https://github.com/meilisearch/documentation/issues/new
     about: For documentation issues, open an issue or a PR in the documentation repository
+  - name: Support questions & other
+    url: https://github.com/meilisearch/meilisearch/discussions/new
+    about: For any other question, open a discussion in this repository

.github/scripts/is-latest-release.sh

@@ -1,41 +1,127 @@
 #!/bin/sh
 
-# Used in our CIs to publish the latest Docker image.
+# Was used in our CIs to publish the latest docker image. Not used anymore, will be used again when v1 and v2 will be out and we will want to maintain multiple stable versions.
+# Returns "true" or "false" (as a string) to be used in the `if` in GHA
 
-# Checks if the current tag ($GITHUB_REF) corresponds to the latest release tag on GitHub
-# Returns "true" or "false" (as a string).
+# Checks if the current tag should be the latest (in terms of semver and not of release date).
+# Ex: previous tag -> v2.1.1
+#     new tag -> v1.20.3
+#     The new tag (v1.20.3) should NOT be the latest
+#     So it returns "false", the `latest` tag should not be updated for the release v1.20.3 and still need to correspond to v2.1.1
 
-GITHUB_API='https://api.github.com/repos/meilisearch/meilisearch/releases'
-PNAME='meilisearch'
+# GLOBAL
+GREP_SEMVER_REGEXP='v\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)$' # i.e. v[number].[number].[number]
 
 # FUNCTIONS
 
-# Returns the version of the latest stable version of Meilisearch by setting the $latest variable.
+# semverParseInto and semverLT from https://github.com/cloudflare/semver_bash/blob/master/semver.sh
+
+# usage: semverParseInto version major minor patch special
+# version: the string version
+# major, minor, patch, special: will be assigned by the function
+semverParseInto() {
+    local RE='[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([0-9A-Za-z-]*\)'
+    #MAJOR
+    eval $2=`echo $1 | sed -e "s#$RE#\1#"`
+    #MINOR
+    eval $3=`echo $1 | sed -e "s#$RE#\2#"`
+    #MINOR
+    eval $4=`echo $1 | sed -e "s#$RE#\3#"`
+    #SPECIAL
+    eval $5=`echo $1 | sed -e "s#$RE#\4#"`
+}
+
+# usage: semverLT version1 version2
+semverLT() {
+    local MAJOR_A=0
+    local MINOR_A=0
+    local PATCH_A=0
+    local SPECIAL_A=0
+
+    local MAJOR_B=0
+    local MINOR_B=0
+    local PATCH_B=0
+    local SPECIAL_B=0
+
+    semverParseInto $1 MAJOR_A MINOR_A PATCH_A SPECIAL_A
+    semverParseInto $2 MAJOR_B MINOR_B PATCH_B SPECIAL_B
+
+    if [ $MAJOR_A -lt $MAJOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -lt $MINOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -le $MINOR_B ] && [ $PATCH_A -lt $PATCH_B ]; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A"  == "_" ] && [ "_$SPECIAL_B"  == "_" ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  == "_" ] && [ "_$SPECIAL_B"  != "_" ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  != "_" ] && [ "_$SPECIAL_B"  == "_" ] ; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A" < "_$SPECIAL_B" ]; then
+        return 0
+    fi
+
+    return 1
+}
+
+# Returns the tag of the latest stable release (in terms of semver and not of release date)
 get_latest() {
-    # temp_file is needed because the grep would start before the download is over
-    temp_file=$(mktemp -q /tmp/$PNAME.XXXXXXXXX)
-    latest_release="$GITHUB_API/latest"
+    temp_file='temp_file' # temp_file needed because the grep would start before the download is over
+    curl -s 'https://api.github.com/repos/meilisearch/meilisearch/releases' > "$temp_file"
+    releases=$(cat "$temp_file" | \
+        grep -E "tag_name|draft|prerelease" \
+        | tr -d ',"' | cut -d ':' -f2 | tr -d ' ')
+        # Returns a list of [tag_name draft_boolean prerelease_boolean ...]
+        # Ex: v0.10.1 false false v0.9.1-rc.1 false true v0.9.0 false false...
 
-    if [ $? -ne 0 ]; then
-        echo "$0: Can't create temp file."
-        exit 1
-    fi
-
-    if [ -z "$GITHUB_PAT" ]; then
-        curl -s "$latest_release" > "$temp_file" || return 1
-    else
-        curl -H "Authorization: token $GITHUB_PAT" -s "$latest_release" > "$temp_file" || return 1
-    fi
-
-    latest="$(cat "$temp_file" | grep '"tag_name":' | cut -d ':' -f2 | tr -d '"' | tr -d ',' | tr -d ' ')"
+    i=0
+    latest=""
+    current_tag=""
+    for release_info in $releases; do
+        if [ $i -eq 0 ]; then # Cheking tag_name
+            if echo "$release_info" | grep -q "$GREP_SEMVER_REGEXP"; then # If it's not an alpha or beta release
+                current_tag=$release_info
+            else
+                current_tag=""
+            fi
+            i=1
+        elif [ $i -eq 1 ]; then # Checking draft boolean
+            if [ "$release_info" = "true" ]; then
+                current_tag=""
+            fi
+            i=2
+        elif [ $i -eq 2 ]; then # Checking prerelease boolean
+            if [ "$release_info" = "true" ]; then
+                current_tag=""
+            fi
+            i=0
+            if [ "$current_tag" != "" ]; then # If the current_tag is valid
+                if [ "$latest" = "" ]; then # If there is no latest yet
+                    latest="$current_tag"
+                else
+                    semverLT $current_tag $latest # Comparing latest and the current tag
+                    if [ $? -eq 1 ]; then
+                        latest="$current_tag"
+                    fi
+                fi
+            fi
+        fi
+    done
 
     rm -f "$temp_file"
-    return 0
+    echo $latest
 }
 
 # MAIN
 current_tag="$(echo $GITHUB_REF | tr -d 'refs/tags/')"
-get_latest
+latest="$(get_latest)"
 
 if [ "$current_tag" != "$latest" ]; then
     # The current release tag is not the latest
@@ -44,5 +130,3 @@ else
     # The current release tag is the latest
     echo "true"
 fi
-
-exit 0

.github/workflows/coverage.yml

@@ -0,0 +1,33 @@
+---
+on:
+  workflow_dispatch:
+
+name: Execute code coverage
+
+jobs:
+  nightly-coverage:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clean
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features --no-fail-fast
+        env:
+          CARGO_INCREMENTAL: "0"
+          RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Cpanic=unwind -Zpanic_abort_tests"
+      - uses: actions-rs/grcov@v0.1
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          file: ${{ steps.coverage.outputs.report }}
+          yml: ./codecov.yml
+          fail_ci_if_error: true

.github/workflows/create-issue-dependencies.yml

@@ -3,7 +3,7 @@ on:
   schedule:
     - cron: '0 0 1 */3 *'
   workflow_dispatch:
-
+  
 jobs:
   create-issue:
     runs-on: ubuntu-latest
@@ -12,12 +12,12 @@ jobs:
     - name: Create an issue
       uses: actions-ecosystem/action-create-issue@v1
       with:
-        github_token: ${{ secrets.MEILI_BOT_GH_PAT }}
+        github_token: ${{ secrets.GITHUB_TOKEN }}
         title: Upgrade dependencies
         body: |
-          We need to update the dependencies of the Meilisearch repository, and, if possible, the dependencies of all the engine-team repositories that Meilisearch depends on (milli, charabia, heed...).
+          We need to update the dependencies of the Meilisearch repository, and, if possible, the dependencies of all the core-team repositories that Meilisearch depends on (milli, charabia, heed...).
 
-          ⚠️ This issue should only be done at the beginning of the sprint!
+          ⚠️ This issue should only be done at the beginning of the sprint!     
         labels: |
           dependencies
           maintenance

.github/workflows/flaky.yml

@@ -1,25 +1,14 @@
 name: Look for flaky tests
 on:
-  workflow_dispatch:
   schedule:
-    - cron: "0 12 * * FRI" # Every Friday at 12:00PM
+    - cron: "0 12 * * FRI" # every friday at 12:00PM
 
 jobs:
   flaky:
-    runs-on: ubuntu-latest
-    container:
-      # Use ubuntu-18.04 to compile with glibc 2.27, which are the production expectations
-      image: ubuntu:18.04
+    runs-on: ubuntu-18.04
+
     steps:
     - uses: actions/checkout@v3
-    - name: Install needed dependencies
-      run: |
-        apt-get update && apt-get install -y curl
-        apt-get install build-essential -y
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        override: true
     - name: Install cargo-flaky
       run: cargo install cargo-flaky
     - name: Run cargo flaky 100 times

.github/workflows/latest-git-tag.yml

@@ -1,29 +0,0 @@
-# Create or update a latest git tag when releasing a stable version of Meilisearch
-name: Update latest git tag
-on:
-  workflow_dispatch:
-  release:
-    types: [released]
-
-jobs:
-  check-version:
-    name: Check the version validity
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Check release validity
-        if: github.event_name == 'release'
-        run: bash .github/scripts/check-release.sh
-
-  update-latest-tag:
-    runs-on: ubuntu-latest
-    needs: check-version
-    steps:
-      - uses: actions/checkout@v3
-      - uses: rickstaa/action-create-tag@v1
-        with:
-          tag: "latest"
-          message: "Latest stable release of Meilisearch"
-          # Move the tag if `latest` already exists
-          force_push_tag: true
-          github_token: ${{ secrets.MEILI_BOT_GH_PAT }}

.github/workflows/milestone-workflow.yml

@@ -1,154 +0,0 @@
-name: Milestone's workflow
-
-# /!\ No git flow are handled here
-
-# For each Milestone created (not opened!), and if the release is NOT a patch release (only the patch changed)
-# - the roadmap issue is created, see https://github.com/meilisearch/engine-team/blob/main/issue-templates/roadmap-issue.md
-# - the changelog issue is created, see https://github.com/meilisearch/engine-team/blob/main/issue-templates/changelog-issue.md
-
-# For each Milestone closed
-# - the `release_version` label is created
-# - this label is applied to all issues/PRs in the Milestone
-
-on:
-  milestone:
-    types: [created, closed]
-
-env:
-  MILESTONE_VERSION: ${{ github.event.milestone.title }}
-  MILESTONE_URL: ${{ github.event.milestone.html_url }}
-  MILESTONE_DUE_ON: ${{ github.event.milestone.due_on }}
-  GH_TOKEN: ${{ secrets.MEILI_BOT_GH_PAT }}
-
-jobs:
-
-# -----------------
-# MILESTONE CREATED
-# -----------------
-
-  get-release-version:
-    if: github.event.action == 'created'
-    runs-on: ubuntu-latest
-    outputs:
-      is-patch: ${{ steps.check-patch.outputs.is-patch }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Check if this release is a patch release only
-        id: check-patch
-        run: |
-          echo version: $MILESTONE_VERSION
-          if [[ $MILESTONE_VERSION =~ ^v[0-9]+\.[0-9]+\.0$ ]]; then
-            echo 'This is NOT a patch release'
-            echo "is-patch=false" >> $GITHUB_OUTPUT
-          elif [[ $MILESTONE_VERSION =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo 'This is a patch release'
-            echo "is-patch=true" >> $GITHUB_OUTPUT
-          else
-            echo "Not a valid format of release, check the Milestone's title."
-            echo 'Should be vX.Y.Z'
-            exit 1
-          fi
-
-  create-roadmap-issue:
-    needs: get-release-version
-    # Create the roadmap issue if the release is not only a patch release
-    if: github.event.action == 'created' && needs.get-release-version.outputs.is-patch == 'false'
-    runs-on: ubuntu-latest
-    env:
-      ISSUE_TEMPLATE: issue-template.md
-    steps:
-      - uses: actions/checkout@v3
-      - name: Download the issue template
-        run: curl -s https://raw.githubusercontent.com/meilisearch/engine-team/main/issue-templates/roadmap-issue.md > $ISSUE_TEMPLATE
-      - name: Replace all empty occurrences in the templates
-        run: |
-          # Replace all <<version>> occurrences
-          sed -i "s/<<version>>/$MILESTONE_VERSION/g" $ISSUE_TEMPLATE
-
-          # Replace all <<milestone_id>> occurrences
-          milestone_id=$(echo $MILESTONE_URL | cut -d '/' -f 7)
-          sed -i "s/<<milestone_id>>/$milestone_id/g" $ISSUE_TEMPLATE
-
-          # Replace release date if exists
-          if [[ ! -z $MILESTONE_DUE_ON ]]; then
-            date=$(echo $MILESTONE_DUE_ON | cut -d 'T' -f 1)
-            sed -i "s/Release date\: 20XX-XX-XX/Release date\: $date/g" $ISSUE_TEMPLATE
-          fi
-      - name: Create the issue
-        run: |
-          gh issue create \
-            --title "$MILESTONE_VERSION ROADMAP" \
-            --label 'epic,impacts docs,impacts integrations,impacts cloud' \
-            --body-file $ISSUE_TEMPLATE \
-            --milestone $MILESTONE_VERSION
-
-  create-changelog-issue:
-    needs: get-release-version
-    # Create the changelog issue if the release is not only a patch release
-    if: github.event.action == 'created' && needs.get-release-version.outputs.is-patch == 'false'
-    runs-on: ubuntu-latest
-    env:
-      ISSUE_TEMPLATE: issue-template.md
-    steps:
-      - uses: actions/checkout@v3
-      - name: Download the issue template
-        run: curl -s https://raw.githubusercontent.com/meilisearch/engine-team/main/issue-templates/changelog-issue.md > $ISSUE_TEMPLATE
-      - name: Replace all empty occurrences in the templates
-        run: |
-          # Replace all <<version>> occurrences
-          sed -i "s/<<version>>/$MILESTONE_VERSION/g" $ISSUE_TEMPLATE
-
-          # Replace all <<milestone_id>> occurrences
-          milestone_id=$(echo $MILESTONE_URL | cut -d '/' -f 7)
-          sed -i "s/<<milestone_id>>/$milestone_id/g" $ISSUE_TEMPLATE
-      - name: Create the issue
-        run: |
-          gh issue create \
-            --title "Create release changelogs for $MILESTONE_VERSION" \
-            --label 'impacts docs,documentation' \
-            --body-file $ISSUE_TEMPLATE \
-            --milestone $MILESTONE_VERSION \
-            --assignee curquiza
-
-# ----------------
-# MILESTONE CLOSED
-# ----------------
-
-  create-release-label:
-    if: github.event.action == 'closed'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Create the ${{ env.MILESTONE_VERSION }} label
-        run: |
-          label_description="PRs/issues solved in $MILESTONE_VERSION"
-          if [[ ! -z $MILESTONE_DUE_ON ]]; then
-            date=$(echo $MILESTONE_DUE_ON | cut -d 'T' -f 1)
-            label_description="$label_description released on $date"
-          fi
-
-          gh api repos/meilisearch/meilisearch/labels \
-            --method POST \
-            -H "Accept: application/vnd.github+json" \
-            -f name="$MILESTONE_VERSION" \
-            -f description="$label_description" \
-            -f color='ff5ba3'
-
-  labelize-all-milestone-content:
-    if: github.event.action == 'closed'
-    needs: create-release-label
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Add label ${{ env.MILESTONE_VERSION }} to all PRs in the Milestone
-        run: |
-          prs=$(gh pr list --search milestone:"$MILESTONE_VERSION" --limit 1000 --state all --json number --template '{{range .}}{{tablerow (printf "%v" .number)}}{{end}}')
-          for pr in $prs; do
-              gh pr edit $pr --add-label $MILESTONE_VERSION
-          done
-      - name: Add label ${{ env.MILESTONE_VERSION }} to all issues in the Milestone
-        run: |
-          issues=$(gh issue list --search milestone:"$MILESTONE_VERSION" --limit 1000 --state all --json number --template '{{range .}}{{tablerow (printf "%v" .number)}}{{end}}')
-          for issue in $issues; do
-              gh issue edit $issue --add-label $MILESTONE_VERSION
-          done

.github/workflows/publish-binaries.yml

@@ -1,7 +1,4 @@
 on:
-  workflow_dispatch:
-  schedule:
-    - cron: '0 2 * * *' # Every day at 2:00am
   release:
     types: [published]
 
@@ -11,129 +8,65 @@ jobs:
   check-version:
     name: Check the version validity
     runs-on: ubuntu-latest
-    # No need to check the version for dry run (cron)
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       # Check if the tag has the v<nmumber>.<number>.<number> format.
       # If yes, it means we are publishing an official release.
       # If no, we are releasing a RC, so no need to check the version.
       - name: Check tag format
-        if: github.event_name == 'release'
+        if: github.event_name != 'schedule'
         id: check-tag-format
         run: |
           escaped_tag=$(printf "%q" ${{ github.ref_name }})
 
           if [[ $escaped_tag =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo "stable=true" >> $GITHUB_OUTPUT
+            echo ::set-output name=stable::true
           else
-            echo "stable=false" >> $GITHUB_OUTPUT
+            echo ::set-output name=stable::false
           fi
       - name: Check release validity
-        if: github.event_name == 'release' && steps.check-tag-format.outputs.stable == 'true'
+        if: steps.check-tag-format.outputs.stable == 'true'
         run: bash .github/scripts/check-release.sh
 
-  publish-linux:
-    name: Publish binary for Linux
-    runs-on: ubuntu-latest
-    needs: check-version
-    container:
-      # Use ubuntu-18.04 to compile with glibc 2.27
-      image: ubuntu:18.04
-    steps:
-    - uses: actions/checkout@v3
-    - name: Install needed dependencies
-      run: |
-        apt-get update && apt-get install -y curl
-        apt-get install build-essential -y
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        override: true
-    - name: Build
-      run: cargo build --release --locked
-    # No need to upload binaries for dry run (cron)
-    - name: Upload binaries to release
-      if: github.event_name == 'release'
-      uses: svenstaro/upload-release-action@2.3.0
-      with:
-        repo_token: ${{ secrets.MEILI_BOT_GH_PAT }}
-        file: target/release/meilisearch
-        asset_name: meilisearch-linux-amd64
-        tag: ${{ github.ref }}
-
-  publish-macos-windows:
+  publish:
     name: Publish binary for ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     needs: check-version
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-12, windows-2022]
+        os: [ubuntu-18.04, macos-latest, windows-latest]
         include:
-          - os: macos-12
+          - os: ubuntu-18.04
+            artifact_name: meilisearch
+            asset_name: meilisearch-linux-amd64
+          - os: macos-latest
             artifact_name: meilisearch
             asset_name: meilisearch-macos-amd64
-          - os: windows-2022
+          - os: windows-latest
             artifact_name: meilisearch.exe
             asset_name: meilisearch-windows-amd64.exe
+
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions-rs/toolchain@v1
+    - uses: hecrj/setup-rust-action@master
       with:
-        toolchain: stable
-        override: true
+        rust-version: stable
+    - uses: actions/checkout@v3
     - name: Build
       run: cargo build --release --locked
-    # No need to upload binaries for dry run (cron)
     - name: Upload binaries to release
-      if: github.event_name == 'release'
-      uses: svenstaro/upload-release-action@2.3.0
+      uses: svenstaro/upload-release-action@v1-release
       with:
-        repo_token: ${{ secrets.MEILI_BOT_GH_PAT }}
+        repo_token: ${{ secrets.PUBLISH_TOKEN }}
         file: target/release/${{ matrix.artifact_name }}
         asset_name: ${{ matrix.asset_name }}
         tag: ${{ github.ref }}
 
-  publish-macos-apple-silicon:
-    name: Publish binary for macOS silicon
-    runs-on: ${{ matrix.os }}
-    needs: check-version
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: macos-12
-            target: aarch64-apple-darwin
-            asset_name: meilisearch-macos-apple-silicon
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-      - name: Installing Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          target: ${{ matrix.target }}
-          override: true
-      - name: Cargo build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release --target ${{ matrix.target }}
-      - name: Upload the binary to release
-        # No need to upload binaries for dry run (cron)
-        if: github.event_name == 'release'
-        uses: svenstaro/upload-release-action@2.3.0
-        with:
-          repo_token: ${{ secrets.MEILI_BOT_GH_PAT }}
-          file: target/${{ matrix.target }}/release/meilisearch
-          asset_name: ${{ matrix.asset_name }}
-          tag: ${{ github.ref }}
-
   publish-aarch64:
     name: Publish binary for aarch64
     runs-on: ${{ matrix.os }}
     needs: check-version
+    continue-on-error: false
     strategy:
       fail-fast: false
       matrix:
@@ -144,9 +77,11 @@ jobs:
             linker: gcc-aarch64-linux-gnu
             use-cross: true
             asset_name: meilisearch-linux-aarch64
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
+
       - name: Installing Rust toolchain
         uses: actions-rs/toolchain@v1
         with:
@@ -154,13 +89,16 @@ jobs:
           profile: minimal
           target: ${{ matrix.target }}
           override: true
+
       - name: APT update
         run: |
           sudo apt update
+
       - name: Install target specific tools
         if: matrix.use-cross
         run: |
           sudo apt-get install -y ${{ matrix.linker }}
+
       - name: Configure target aarch64 GNU
         if: matrix.target == 'aarch64-unknown-linux-gnu'
         ## Environment variable is not passed using env:
@@ -172,20 +110,22 @@ jobs:
           echo '[target.aarch64-unknown-linux-gnu]' >> ~/.cargo/config
           echo 'linker = "aarch64-linux-gnu-gcc"' >> ~/.cargo/config
           echo 'JEMALLOC_SYS_WITH_LG_PAGE=16' >> $GITHUB_ENV
+          echo RUSTFLAGS="-Clink-arg=-fuse-ld=gold" >> $GITHUB_ENV
+
       - name: Cargo build
         uses: actions-rs/cargo@v1
         with:
           command: build
           use-cross: ${{ matrix.use-cross }}
           args: --release --target ${{ matrix.target }}
+
       - name: List target output files
         run: ls -lR ./target
+
       - name: Upload the binary to release
-        # No need to upload binaries for dry run (cron)
-        if: github.event_name == 'release'
-        uses: svenstaro/upload-release-action@2.3.0
+        uses: svenstaro/upload-release-action@v1-release
         with:
-          repo_token: ${{ secrets.MEILI_BOT_GH_PAT }}
+          repo_token: ${{ secrets.PUBLISH_TOKEN }}
           file: target/${{ matrix.target }}/release/meilisearch
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}

.github/workflows/publish-deb-brew-pkg.yml

@@ -1,4 +1,4 @@
-name: Publish to APT repository & Homebrew
+name: Publish deb pkg to GitHub release & APT repository & Homebrew
 
 on:
   release:
@@ -9,35 +9,27 @@ jobs:
     name: Check the version validity
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - name: Check release validity
         run: bash .github/scripts/check-release.sh
 
   debian:
     name: Publish debian packagge
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04
     needs: check-version
-    container:
-      # Use ubuntu-18.04 to compile with glibc 2.27
-      image: ubuntu:18.04
     steps:
-    - name: Install needed dependencies
-      run: |
-        apt-get update && apt-get install -y curl
-        apt-get install build-essential -y
-    - uses: actions-rs/toolchain@v1
+    - uses: hecrj/setup-rust-action@master
       with:
-        toolchain: stable
-        override: true
+        rust-version: stable
     - name: Install cargo-deb
       run: cargo install cargo-deb
     - uses: actions/checkout@v3
     - name: Build deb package
-      run: cargo deb -p meilisearch -o target/debian/meilisearch.deb
+      run: cargo deb -p meilisearch-http -o target/debian/meilisearch.deb
     - name: Upload debian pkg to release
-      uses: svenstaro/upload-release-action@2.3.0
+      uses: svenstaro/upload-release-action@v1-release
       with:
-        repo_token: ${{ secrets.MEILI_BOT_GH_PAT }}
+        repo_token: ${{ secrets.GITHUB_TOKEN }}
         file: target/debian/meilisearch.deb
         asset_name: meilisearch.deb
         tag: ${{ github.ref }}
@@ -46,11 +38,11 @@ jobs:
 
   homebrew:
     name: Bump Homebrew formula
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04
     needs: check-version
     steps:
       - name: Create PR to Homebrew
-        uses: mislav/bump-homebrew-formula-action@v2
+        uses: mislav/bump-homebrew-formula-action@v1
         with:
           formula-name: meilisearch
         env:

.github/workflows/publish-docker-images.yml

@@ -1,16 +1,10 @@
 ---
 on:
-  push:
-    # Will run for every tag pushed except `latest`
-    # When the `latest` git tag is created with this [CI](../latest-git-tag.yml)
-    # we don't need to create a Docker `latest` image again.
-    # The `latest` Docker image push is already done in this CI when releasing a stable version of Meilisearch.
-    tags-ignore:
-      - latest
-  # Both `schedule` and `workflow_dispatch` build the nightly tag
   schedule:
-    - cron: '0 23 * * *' # Every day at 11:00pm
-  workflow_dispatch:
+    - cron: '0 4 * * *' # Every day at 4:00am
+  push:
+    tags:
+      - '*'
 
 name: Publish tagged images to Docker Hub
 
@@ -18,48 +12,29 @@ jobs:
   docker:
     runs-on: docker
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
-      # If we are running a cron or manual job ('schedule' or 'workflow_dispatch' event), it means we are publishing the `nightly` tag, so not considered stable.
-      # If we have pushed a tag, and the tag has the v<nmumber>.<number>.<number> format, it means we are publishing an official release, so considered stable.
+      # Check if the tag has the v<nmumber>.<number>.<number> format. If yes, it means we are publishing an official release.
       # In this situation, we need to set `output.stable` to create/update the following tags (additionally to the `vX.Y.Z` Docker tag):
       # - a `vX.Y` (without patch version) Docker tag
       # - a `latest` Docker tag
-      # For any other tag pushed, this is not considered stable.
-      - name: Define if stable and latest release
+      - name: Check tag format
+        if: github.event_name != 'schedule'
         id: check-tag-format
-        env:
-          # To avoid request limit with the .github/scripts/is-latest-release.sh script
-          GITHUB_PATH: ${{ secrets.MEILI_BOT_GH_PAT }}
         run: |
           escaped_tag=$(printf "%q" ${{ github.ref_name }})
-          echo "latest=false" >> $GITHUB_OUTPUT
 
-          if [[ ${{ github.event_name }} != 'push' ]]; then
-            echo "stable=false" >> $GITHUB_OUTPUT
-          elif [[ $escaped_tag =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo "stable=true" >> $GITHUB_OUTPUT
-            echo "latest=$(sh .github/scripts/is-latest-release.sh)" >> $GITHUB_OUTPUT
+          if [[ $escaped_tag =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo ::set-output name=stable::true
           else
-            echo "stable=false" >> $GITHUB_OUTPUT
+            echo ::set-output name=stable::false
           fi
 
-      # Check only the validity of the tag for stable releases (not for pre-releases or other tags)
+      # Check only the validity of the tag for official releases (not for pre-releases or other tags)
       - name: Check release validity
-        if: steps.check-tag-format.outputs.stable == 'true'
+        if: github.event_name != 'schedule' && steps.check-tag-format.outputs.stable == 'true'
         run: bash .github/scripts/check-release.sh
 
-      - name: Set build-args for Docker buildx
-        id: build-metadata
-        run: |
-          # Define ownership
-          git config --global --add safe.directory /home/meili/actions-runner/_work/meilisearch/meilisearch
-
-          # Extract commit date
-          commit_date=$(git show -s --format=%cd --date=iso-strict ${{ github.sha }})
-
-          echo "date=$commit_date" >> $GITHUB_OUTPUT
-
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
 
@@ -67,6 +42,7 @@ jobs:
         uses: docker/setup-buildx-action@v2
 
       - name: Login to Docker Hub
+        if: github.event_name != 'schedule'
         uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -77,32 +53,19 @@ jobs:
         uses: docker/metadata-action@v4
         with:
           images: getmeili/meilisearch
-          # Prevent `latest` to be updated for each new tag pushed.
-          # We need latest and `vX.Y` tags to only be pushed for the stable Meilisearch releases.
+          # The lastest and `vX.Y` tags are only pushed for the official Meilisearch releases
+          # See https://github.com/docker/metadata-action#latest-tag
           flavor: latest=false
           tags: |
             type=ref,event=tag
-            type=raw,value=nightly,enable=${{ github.event_name != 'push' }}
             type=semver,pattern=v{{major}}.{{minor}},enable=${{ steps.check-tag-format.outputs.stable == 'true' }}
-            type=raw,value=latest,enable=${{ steps.check-tag-format.outputs.stable == 'true' && steps.check-tag-format.outputs.latest == 'true' }}
+            type=raw,value=latest,enable=${{ steps.check-tag-format.outputs.stable == 'true' }}
 
       - name: Build and push
+        id: docker_build
         uses: docker/build-push-action@v3
         with:
-          push: true
+          # We do not push tags for the cron jobs, this is only for test purposes
+          push: ${{ github.event_name != 'schedule' }}
           platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta.outputs.tags }}
-          build-args: |
-            COMMIT_SHA=${{ github.sha }}
-            COMMIT_DATE=${{ steps.build-metadata.outputs.date }}
-
-      # /!\ Don't touch this without checking with Cloud team
-      - name: Send CI information to Cloud team
-        # Do not send if nightly build (i.e. 'schedule' or 'workflow_dispatch' event)
-        if: github.event_name == 'push'
-        uses: peter-evans/repository-dispatch@v2
-        with:
-          token: ${{ secrets.MEILI_BOT_GH_PAT }}
-          repository: meilisearch/meilisearch-cloud
-          event-type: cloud-docker-build
-          client-payload: '{ "meilisearch_version": "${{ github.ref_name }}", "stable": "${{ steps.check-tag-format.outputs.stable }}" }'

.github/workflows/rust.yml

@@ -15,46 +15,17 @@ env:
   RUSTFLAGS: "-D warnings"
 
 jobs:
-  test-linux:
-    name: Tests on ubuntu-18.04
-    runs-on: ubuntu-latest
-    container:
-      # Use ubuntu-18.04 to compile with glibc 2.27, which are the production expectations
-      image: ubuntu:18.04
-    steps:
-    - uses: actions/checkout@v3
-    - name: Install needed dependencies
-      run: |
-        apt-get update && apt-get install -y curl
-        apt-get install build-essential -y
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        override: true
-    - name: Cache dependencies
-      uses: Swatinem/rust-cache@v2.2.0
-    - name: Run cargo check without any default features
-      uses: actions-rs/cargo@v1
-      with:
-        command: build
-        args: --locked --release --no-default-features
-    - name: Run cargo test
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --locked --release
-
-  test-others:
+  tests:
     name: Tests on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-12, windows-2022]
+        os: [ubuntu-18.04, macos-latest, windows-latest]
     steps:
     - uses: actions/checkout@v3
     - name: Cache dependencies
-      uses: Swatinem/rust-cache@v2.2.0
+      uses: Swatinem/rust-cache@v2.0.0
     - name: Run cargo check without any default features
       uses: actions-rs/cargo@v1
       with:
@@ -69,22 +40,16 @@ jobs:
   # We run tests in debug also, to make sure that the debug_assertions are hit
   test-debug:
     name: Run tests in debug
-    runs-on: ubuntu-latest
-    container:
-      # Use ubuntu-18.04 to compile with glibc 2.27, which are the production expectations
-      image: ubuntu:18.04
+    runs-on: ubuntu-18.04
     steps:
       - uses: actions/checkout@v3
-      - name: Install needed dependencies
-        run: |
-          apt-get update && apt-get install -y curl
-          apt-get install build-essential -y
       - uses: actions-rs/toolchain@v1
         with:
+          profile: minimal
           toolchain: stable
           override: true
       - name: Cache dependencies
-        uses: Swatinem/rust-cache@v2.2.0
+        uses: Swatinem/rust-cache@v2.0.0
       - name: Run tests in debug
         uses: actions-rs/cargo@v1
         with:
@@ -93,7 +58,7 @@ jobs:
 
   clippy:
     name: Run Clippy
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04
     steps:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
@@ -103,25 +68,25 @@ jobs:
           override: true
           components: clippy
       - name: Cache dependencies
-        uses: Swatinem/rust-cache@v2.2.0
+        uses: Swatinem/rust-cache@v2.0.0
       - name: Run cargo clippy
         uses: actions-rs/cargo@v1
         with:
           command: clippy
-          args: --all-targets -- --deny warnings --allow clippy::uninlined_format_args
+          args: --all-targets -- --deny warnings
 
   fmt:
     name: Run Rustfmt
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04
     steps:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly
+          toolchain: stable
           override: true
           components: rustfmt
       - name: Cache dependencies
-        uses: Swatinem/rust-cache@v2.2.0
+        uses: Swatinem/rust-cache@v2.0.0
       - name: Run cargo fmt
         run: cargo fmt --all -- --check

.github/workflows/update-cargo-toml-version.yml

@@ -1,48 +0,0 @@
-name: Update Meilisearch version in all Cargo.toml files
-
-on:
-  workflow_dispatch:
-    inputs:
-      new_version:
-        description: 'The new version (vX.Y.Z)'
-        required: true
-
-env:
-  NEW_VERSION: ${{ github.event.inputs.new_version }}
-  NEW_BRANCH: update-version-${{ github.event.inputs.new_version }}
-  GH_TOKEN: ${{ secrets.MEILI_BOT_GH_PAT }}
-
-jobs:
-
-  update-version-cargo-toml:
-    name: Update version in Cargo.toml files
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Install sd
-        run: cargo install sd
-      - name: Update Cargo.toml files
-        run: |
-          raw_new_version=$(echo $NEW_VERSION | cut -d 'v' -f 2)
-          new_string="version = \"$raw_new_version\""
-          sd '^version = "\d+.\d+.\w+"$' "$new_string" */Cargo.toml
-      - name: Build Meilisearch to update Cargo.lock
-        run: cargo build
-      - name: Commit and push the changes to the ${{ env.NEW_BRANCH }} branch
-        uses: EndBug/add-and-commit@v9
-        with:
-          message: "Update version for the next release (${{ env.NEW_VERSION }}) in Cargo.toml files"
-          new_branch: ${{ env.NEW_BRANCH }}
-      - name: Create the PR pointing to ${{ github.ref_name }}
-        run: |
-          gh pr create \
-            --title "Update version for the next release ($NEW_VERSION) in Cargo.toml files" \
-            --body '⚠️ This PR is automatically generated. Check the new version is the expected one before merging.' \
-            --label 'skip changelog' \
-            --milestone $NEW_VERSION \
-            --base $GITHUB_REF_NAME

.gitignore

@@ -7,10 +7,3 @@
 /data.ms
 /snapshots
 /dumps
-
-
-# Snapshots
-## ... large
-*.full.snap
-##  ... unreviewed
-*.snap.new

.rustfmt.toml

@@ -1,5 +0,0 @@
-unstable_features = true
-
-use_small_heuristics = "max"
-imports_granularity = "Module"
-group_imports = "StdExternalCrate"

CONTRIBUTING.md

@@ -97,12 +97,12 @@ _[Read more about this](https://github.com/meilisearch/integration-guides/blob/m
 
 ### How to Publish a new Release
 
-The full Meilisearch release process is described in [this guide](https://github.com/meilisearch/engine-team/blob/main/resources/meilisearch-release.md). Please follow it carefully before doing any release.
+The full Meilisearch release process is described in [this guide](https://github.com/meilisearch/core-team/blob/main/resources/meilisearch-release.md). Please follow it carefully before doing any release.
 
 ### Release assets
 
 For each release, the following assets are created:
-- Binaries for different platforms (Linux, MacOS, Windows and ARM architectures) are attached to the GitHub release
+- Binaries for differents platforms (Linux, MacOS, Windows and ARM architectures) are attached to the GitHub release
 - Binaries are pushed to HomeBrew and APT (not published for RC)
 - Docker tags are created/updated:
   - `vX.Y.Z`

Cargo.toml

@@ -1,13 +1,10 @@
 [workspace]
 resolver = "2"
 members = [
-    "meilisearch",
+    "meilisearch-http",
     "meilisearch-types",
+    "meilisearch-lib",
     "meilisearch-auth",
-    "meili-snap",
-    "index-scheduler",
-    "dump",
-    "file-store",
     "permissive-json-pointer",
 ]
 

Dockerfile

@@ -7,7 +7,7 @@ WORKDIR /meilisearch
 
 ARG     COMMIT_SHA
 ARG     COMMIT_DATE
-ENV     VERGEN_GIT_SHA=${COMMIT_SHA} VERGEN_GIT_COMMIT_TIMESTAMP=${COMMIT_DATE}
+ENV     COMMIT_SHA=${COMMIT_SHA} COMMIT_DATE=${COMMIT_DATE}
 ENV     RUSTFLAGS="-C target-feature=-crt-static"
 
 COPY    . .

README.md

@@ -9,7 +9,7 @@
   <a href="https://blog.meilisearch.com">Blog</a> |
   <a href="https://docs.meilisearch.com">Documentation</a> |
   <a href="https://docs.meilisearch.com/faq/">FAQ</a> |
-  <a href="https://discord.meilisearch.com">Discord</a>
+  <a href="https://slack.meilisearch.com">Slack</a>
 </h4>
 
 <p align="center">
@@ -61,7 +61,7 @@ You may also want to check out [Meilisearch 101](https://docs.meilisearch.com/le
 
 ## ☁️ Meilisearch cloud
 
-Let us manage your infrastructure so you can focus on integrating a great search experience. Try [Meilisearch Cloud](https://meilisearch.com/pricing) today.
+Join the closed beta for Meilisearch cloud by filling out [this form](https://meilisearch.typeform.com/to/VI2cI2rv).
 
 ## 🧰 SDKs & integration tools
 
@@ -97,7 +97,7 @@ Meilisearch is a search engine created by [Meili](https://www.welcometothejungle
 
 - For feature requests, please visit our [product repository](https://github.com/meilisearch/product/discussions)
 - Found a bug? Open an [issue](https://github.com/meilisearch/meilisearch/issues)!
-- Want to be part of our Discord community? [Join us!](https://discord.gg/meilisearch)
+- Want to be part of our Slack community? [Join us!](https://slack.meilisearch.com/)
 - For everything else, please check [this page listing some of the other places where you can find us](https://docs.meilisearch.com/learn/what_is_meilisearch/contact.html)
 
 Thank you for your support!

bors.toml

@@ -1,7 +1,7 @@
 status = [
     'Tests on ubuntu-18.04',
-    'Tests on macos-12',
-    'Tests on windows-2022',
+    'Tests on macos-latest',
+    'Tests on windows-latest',
     'Run Clippy',
     'Run Rustfmt',
     'Run tests in debug',

config.toml

@@ -1,120 +0,0 @@
-# This file shows the default configuration of Meilisearch.
-# All variables are defined here: https://docs.meilisearch.com/learn/configuration/instance_options.html#environment-variables
-
-db_path = "./data.ms"
-# Designates the location where database files will be created and retrieved.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#database-path
-
-env = "development"
-# Configures the instance's environment. Value must be either `production` or `development`.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#environment
-
-http_addr = "localhost:7700"
-# The address on which the HTTP server will listen.
-
-# master_key = "YOUR_MASTER_KEY_VALUE"
-# Sets the instance's master key, automatically protecting all routes except GET /health.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#master-key
-
-# no_analytics = true
-# Deactivates Meilisearch's built-in telemetry when provided.
-# Meilisearch automatically collects data from all instances that do not opt out using this flag.
-# All gathered data is used solely for the purpose of improving Meilisearch, and can be deleted at any time.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#disable-analytics
-
-http_payload_size_limit = "100 MB"
-# Sets the maximum size of accepted payloads.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#payload-limit-size
-
-log_level = "INFO"
-# Defines how much detail should be present in Meilisearch's logs.
-# Meilisearch currently supports six log levels, listed in order of increasing verbosity:  `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#log-level
-
-# max_indexing_memory = "2 GiB"
-# Sets the maximum amount of RAM Meilisearch can use when indexing.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#max-indexing-memory
-
-# max_indexing_threads = 4
-# Sets the maximum number of threads Meilisearch can use during indexing.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#max-indexing-threads
-
-#############
-### DUMPS ###
-#############
-
-dump_dir = "dumps/"
-# Sets the directory where Meilisearch will create dump files.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#dumps-destination
-
-# import_dump = "./path/to/my/file.dump"
-# Imports the dump file located at the specified path. Path must point to a .dump file.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#import-dump
-
-ignore_missing_dump = false
-# Prevents Meilisearch from throwing an error when `import_dump` does not point to a valid dump file.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ignore-missing-dump
-
-ignore_dump_if_db_exists = false
-# Prevents a Meilisearch instance with an existing database from throwing an error when using `import_dump`.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ignore-dump-if-db-exists
-
-
-#################
-### SNAPSHOTS ###
-#################
-
-schedule_snapshot = false
-# Enables scheduled snapshots when true, disable when false (the default).
-# If the value is given as an integer, then enables the scheduled snapshot with the passed value as the interval
-# between each snapshot, in seconds.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#schedule-snapshot-creation
-
-snapshot_dir = "snapshots/"
-# Sets the directory where Meilisearch will store snapshots.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#snapshot-destination
-
-# import_snapshot = "./path/to/my/snapshot"
-# Launches Meilisearch after importing a previously-generated snapshot at the given filepath.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#import-snapshot
-
-ignore_missing_snapshot = false
-# Prevents a Meilisearch instance from throwing an error when `import_snapshot` does not point to a valid snapshot file.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ignore-missing-snapshot
-
-ignore_snapshot_if_db_exists = false
-# Prevents a Meilisearch instance with an existing database from throwing an error when using `import_snapshot`.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ignore-snapshot-if-db-exists
-
-
-###########
-### SSL ###
-###########
-
-# ssl_auth_path = "./path/to/root"
-# Enables client authentication in the specified path.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-authentication-path
-
-# ssl_cert_path = "./path/to/certfile"
-# Sets the server's SSL certificates.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-certificates-path
-
-# ssl_key_path = "./path/to/private-key"
-# Sets the server's SSL key files.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-key-path
-
-# ssl_ocsp_path = "./path/to/ocsp-file"
-# Sets the server's OCSP file.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-ocsp-path
-
-ssl_require_auth = false
-# Makes SSL authentication mandatory.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-require-auth
-
-ssl_resumption = false
-# Activates SSL session resumption.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-resumption
-
-ssl_tickets = false
-# Activates SSL tickets.
-# https://docs.meilisearch.com/learn/configuration/instance_options.html#ssl-tickets

download-latest.sh

@@ -1,51 +1,129 @@
 #!/bin/sh
 
-# This script can optionally use a GitHub token to increase your request limit (for example, if using this script in a CI).
-# To use a GitHub token, pass it through the GITHUB_PAT environment variable.
-
-# GLOBALS
-
-# Colors
+# COLORS
 RED='\033[31m'
 GREEN='\033[32m'
 DEFAULT='\033[0m'
 
-# Project name
-PNAME='meilisearch'
-
-# GitHub API address
-GITHUB_API='https://api.github.com/repos/meilisearch/meilisearch/releases'
-# GitHub Release address
-GITHUB_REL='https://github.com/meilisearch/meilisearch/releases/download/'
+# GLOBALS
+GREP_SEMVER_REGEXP='v\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)$' # i.e. v[number].[number].[number]
 
 # FUNCTIONS
 
-# Gets the version of the latest stable version of Meilisearch by setting the $latest variable.
-# Returns 0 in case of success, 1 otherwise.
-get_latest() {
-    # temp_file is needed because the grep would start before the download is over
-    temp_file=$(mktemp -q /tmp/$PNAME.XXXXXXXXX)
-    latest_release="$GITHUB_API/latest"
+# semverParseInto and semverLT from https://github.com/cloudflare/semver_bash/blob/master/semver.sh
 
-    if [ $? -ne 0 ]; then
-        echo "$0: Can't create temp file."
-        fetch_release_failure_usage
-        exit 1
+# usage: semverParseInto version major minor patch special
+# version: the string version
+# major, minor, patch, special: will be assigned by the function
+semverParseInto() {
+    local RE='[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([0-9A-Za-z-]*\)'
+    #MAJOR
+    eval $2=`echo $1 | sed -e "s#$RE#\1#"`
+    #MINOR
+    eval $3=`echo $1 | sed -e "s#$RE#\2#"`
+    #PATCH
+    eval $4=`echo $1 | sed -e "s#$RE#\3#"`
+    #SPECIAL
+    eval $5=`echo $1 | sed -e "s#$RE#\4#"`
+}
+
+# usage: semverLT version1 version2
+semverLT() {
+    local MAJOR_A=0
+    local MINOR_A=0
+    local PATCH_A=0
+    local SPECIAL_A=0
+
+    local MAJOR_B=0
+    local MINOR_B=0
+    local PATCH_B=0
+    local SPECIAL_B=0
+
+    semverParseInto $1 MAJOR_A MINOR_A PATCH_A SPECIAL_A
+    semverParseInto $2 MAJOR_B MINOR_B PATCH_B SPECIAL_B
+
+    if [ $MAJOR_A -lt $MAJOR_B ]; then
+        return 0
     fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -lt $MINOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -le $MINOR_B ] && [ $PATCH_A -lt $PATCH_B ]; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A"  == '_' ] && [ "_$SPECIAL_B"  == '_' ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  == '_' ] && [ "_$SPECIAL_B"  != '_' ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  != '_' ] && [ "_$SPECIAL_B"  == '_' ] ; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A" < "_$SPECIAL_B" ]; then
+        return 0
+    fi
+
+    return 1
+}
+
+# Get a token from https://github.com/settings/tokens to increase rate limit (from 60 to 5000), make sure the token scope is set to 'public_repo'
+# Create GITHUB_PAT environment variable once you acquired the token to start using it
+# Returns the tag of the latest stable release (in terms of semver and not of release date)
+get_latest() {
+    temp_file='temp_file' # temp_file needed because the grep would start before the download is over
 
     if [ -z "$GITHUB_PAT" ]; then
-        curl -s "$latest_release" > "$temp_file" || return 1
+        curl -s 'https://api.github.com/repos/meilisearch/meilisearch/releases' > "$temp_file" || return 1
     else
-        curl -H "Authorization: token $GITHUB_PAT" -s "$latest_release" > "$temp_file" || return 1
+        curl -H "Authorization: token $GITHUB_PAT" -s 'https://api.github.com/repos/meilisearch/meilisearch/releases' > "$temp_file" || return 1
     fi
 
-    latest="$(cat "$temp_file" | grep '"tag_name":' | cut -d ':' -f2 | tr -d '"' | tr -d ',' | tr -d ' ')"
+    releases=$(cat "$temp_file" | \
+        grep -E '"tag_name":|"draft":|"prerelease":' \
+        | tr -d ',"' | cut -d ':' -f2 | tr -d ' ')
+        # Returns a list of [tag_name draft_boolean prerelease_boolean ...]
+        # Ex: v0.10.1 false false v0.9.1-rc.1 false true v0.9.0 false false...
+
+    i=0
+    latest=''
+    current_tag=''
+    for release_info in $releases; do
+        if [ $i -eq 0 ]; then # Checking tag_name
+            if echo "$release_info" | grep -q "$GREP_SEMVER_REGEXP"; then # If it's not an alpha or beta release
+                current_tag=$release_info
+            else
+                current_tag=''
+            fi
+            i=1
+        elif [ $i -eq 1 ]; then # Checking draft boolean
+            if [ "$release_info" = 'true' ]; then
+                current_tag=''
+            fi
+            i=2
+        elif [ $i -eq 2 ]; then # Checking prerelease boolean
+            if [ "$release_info" = 'true' ]; then
+                current_tag=''
+            fi
+            i=0
+            if [ "$current_tag" != '' ]; then # If the current_tag is valid
+                if [ "$latest" = '' ]; then # If there is no latest yet
+                    latest="$current_tag"
+                else
+                    semverLT $current_tag $latest # Comparing latest and the current tag
+                    if [ $? -eq 1 ]; then
+                        latest="$current_tag"
+                    fi
+                fi
+            fi
+        fi
+    done
 
     rm -f "$temp_file"
     return 0
 }
 
-# Gets the OS by setting the $os variable.
+# Gets the OS by setting the $os variable
 # Returns 0 in case of success, 1 otherwise.
 get_os() {
     os_name=$(uname -s)
@@ -56,7 +134,7 @@ get_os() {
     'Linux')
         os='linux'
         ;;
-     'MINGW'*)
+	'MINGW'*)
         os='windows'
         ;;
     *)
@@ -65,7 +143,7 @@ get_os() {
     return 0
 }
 
-# Gets the architecture by setting the $archi variable.
+# Gets the architecture by setting the $archi variable
 # Returns 0 in case of success, 1 otherwise.
 get_archi() {
     architecture=$(uname -m)
@@ -74,9 +152,8 @@ get_archi() {
         archi='amd64'
         ;;
     'arm64')
-        # macOS M1/M2
-        if [ $os = 'macos' ]; then
-            archi='apple-silicon'
+        if [ $os = 'macos' ]; then # MacOS M1
+            archi='amd64'
         else
             archi='aarch64'
         fi
@@ -94,9 +171,9 @@ success_usage() {
     printf "$GREEN%s\n$DEFAULT" "Meilisearch $latest binary successfully downloaded as '$binary_name' file."
     echo ''
     echo 'Run it:'
-    echo "    $ ./$PNAME"
+    echo '    $ ./meilisearch'
     echo 'Usage:'
-    echo "    $ ./$PNAME --help"
+    echo '    $ ./meilisearch --help'
 }
 
 not_available_failure_usage() {
@@ -110,58 +187,54 @@ fetch_release_failure_usage() {
     echo ''
     printf "$RED%s\n$DEFAULT" 'ERROR: Impossible to get the latest stable version of Meilisearch.'
     echo 'Please let us know about this issue: https://github.com/meilisearch/meilisearch/issues/new/choose'
-    echo ''
-    echo 'In the meantime, you can manually download the appropriate binary from the GitHub release assets here: https://github.com/meilisearch/meilisearch/releases/latest'
-}
-
-fill_release_variables() {
-    # Fill $latest variable.
-    if ! get_latest; then
-        fetch_release_failure_usage
-        exit 1
-    fi
-    if [ "$latest" = '' ]; then
-        fetch_release_failure_usage
-        exit 1
-     fi
-     # Fill $os variable.
-     if ! get_os; then
-        not_available_failure_usage
-        exit 1
-     fi
-     # Fill $archi variable.
-     if ! get_archi; then
-        not_available_failure_usage
-        exit 1
-     fi
-}
-
-download_binary() {
-    fill_release_variables
-    echo "Downloading Meilisearch binary $latest for $os, architecture $archi..."
-    case "$os" in
-        'windows')
-            release_file="$PNAME-$os-$archi.exe"
-            binary_name="$PNAME.exe"
-            ;;
-        *)
-            release_file="$PNAME-$os-$archi"
-            binary_name="$PNAME"
-    esac
-    # Fetch the Meilisearch binary.
-    curl --fail -OL "$GITHUB_REL/$latest/$release_file"
-    if [ $? -ne 0 ]; then
-        fetch_release_failure_usage
-        exit 1
-    fi
-    mv "$release_file" "$binary_name"
-    chmod 744 "$binary_name"
-    success_usage
 }
 
 # MAIN
 
-main() {
-    download_binary
-}
-main
+# Fill $latest variable
+if ! get_latest; then
+    fetch_release_failure_usage # TO CHANGE
+    exit 1
+fi
+
+if [ "$latest" = '' ]; then
+    fetch_release_failure_usage
+    exit 1
+fi
+
+# Fill $os variable
+if ! get_os; then
+    not_available_failure_usage
+    exit 1
+fi
+
+# Fill $archi variable
+if ! get_archi; then
+    not_available_failure_usage
+    exit 1
+fi
+
+echo "Downloading Meilisearch binary $latest for $os, architecture $archi..."
+case "$os" in
+    'windows')
+        release_file="meilisearch-$os-$archi.exe"
+        binary_name='meilisearch.exe'
+
+        ;;
+    *)
+        release_file="meilisearch-$os-$archi"
+        binary_name='meilisearch'
+
+esac
+
+# Fetch the Meilisearch binary
+link="https://github.com/meilisearch/meilisearch/releases/download/$latest/$release_file"
+curl --fail -OL "$link"
+if [ $? -ne 0 ]; then
+    fetch_release_failure_usage
+    exit 1
+fi
+
+mv "$release_file" "$binary_name"
+chmod 744 "$binary_name"
+success_usage

dump/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "dump"
-version = "1.0.0"
-edition = "2021"
-
-[dependencies]
-anyhow = "1.0.65"
-flate2 = "1.0.22"
-http = "0.2.8"
-log = "0.4.17"
-meilisearch-auth = { path = "../meilisearch-auth" }
-meilisearch-types = { path = "../meilisearch-types" }
-once_cell = "1.15.0"
-regex = "1.6.0"
-roaring = { version = "0.10.0", features = ["serde"] }
-serde = { version = "1.0.136", features = ["derive"] }
-serde_json = { version = "1.0.85", features = ["preserve_order"] }
-tar = "0.4.38"
-tempfile = "3.3.0"
-thiserror = "1.0.30"
-time = { version = "0.3.7", features = ["serde-well-known", "formatting", "parsing", "macros"] }
-uuid = { version = "1.1.2", features = ["serde", "v4"] }
-
-[dev-dependencies]
-big_s = "1.0.2"
-maplit = "1.0.2"
-meili-snap = { path = "../meili-snap" }
-meilisearch-types = { path = "../meilisearch-types" }

dump/README.md

@@ -1,17 +0,0 @@
-```
-dump
-├── indexes
-│   ├── cattos
-│   │   ├── documents.jsonl
-│   │   └── settings.json
-│   └── doggos
-│       ├── documents.jsonl
-│       └── settings.json
-├── instance-uid.uuid
-├── keys.jsonl
-├── metadata.json
-└── tasks
-    ├── update_files
-    │   └── [task_id].jsonl
-    └── queue.jsonl
-```

dump/src/error.rs

@@ -1,34 +0,0 @@
-use meilisearch_types::error::{Code, ErrorCode};
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("Bad index name.")]
-    BadIndexName,
-    #[error("Malformed task.")]
-    MalformedTask,
-
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-    #[error(transparent)]
-    Serde(#[from] serde_json::Error),
-    #[error(transparent)]
-    Uuid(#[from] uuid::Error),
-}
-
-impl ErrorCode for Error {
-    fn error_code(&self) -> Code {
-        match self {
-            Error::Io(e) => e.error_code(),
-
-            // These errors either happen when creating a dump and don't need any error code,
-            // or come from an internal bad deserialization.
-            Error::Serde(_) => Code::Internal,
-            Error::Uuid(_) => Code::Internal,
-
-            // all these errors should never be raised when creating a dump, thus no error code should be associated.
-            Error::BadIndexName => Code::Internal,
-            Error::MalformedTask => Code::Internal,
-        }
-    }
-}

dump/src/lib.rs

@@ -1,463 +0,0 @@
-#![allow(clippy::type_complexity)]
-#![allow(clippy::wrong_self_convention)]
-
-use meilisearch_types::error::ResponseError;
-use meilisearch_types::keys::Key;
-use meilisearch_types::milli::update::IndexDocumentsMethod;
-use meilisearch_types::settings::Unchecked;
-use meilisearch_types::tasks::{Details, IndexSwap, KindWithContent, Status, Task, TaskId};
-use meilisearch_types::InstanceUid;
-use roaring::RoaringBitmap;
-use serde::{Deserialize, Serialize};
-use time::OffsetDateTime;
-
-mod error;
-mod reader;
-mod writer;
-
-pub use error::Error;
-pub use reader::{DumpReader, UpdateFile};
-pub use writer::DumpWriter;
-
-const CURRENT_DUMP_VERSION: Version = Version::V6;
-
-type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Metadata {
-    pub dump_version: Version,
-    pub db_version: String,
-    #[serde(with = "time::serde::rfc3339")]
-    pub dump_date: OffsetDateTime,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct IndexMetadata {
-    pub uid: String,
-    pub primary_key: Option<String>,
-    #[serde(with = "time::serde::rfc3339")]
-    pub created_at: OffsetDateTime,
-    #[serde(with = "time::serde::rfc3339")]
-    pub updated_at: OffsetDateTime,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
-pub enum Version {
-    V1,
-    V2,
-    V3,
-    V4,
-    V5,
-    V6,
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TaskDump {
-    pub uid: TaskId,
-    #[serde(default)]
-    pub index_uid: Option<String>,
-    pub status: Status,
-    #[serde(rename = "type")]
-    pub kind: KindDump,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub canceled_by: Option<TaskId>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub details: Option<Details>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<ResponseError>,
-
-    #[serde(with = "time::serde::rfc3339")]
-    pub enqueued_at: OffsetDateTime,
-    #[serde(
-        with = "time::serde::rfc3339::option",
-        skip_serializing_if = "Option::is_none",
-        default
-    )]
-    pub started_at: Option<OffsetDateTime>,
-    #[serde(
-        with = "time::serde::rfc3339::option",
-        skip_serializing_if = "Option::is_none",
-        default
-    )]
-    pub finished_at: Option<OffsetDateTime>,
-}
-
-// A `Kind` specific version made for the dump. If modified you may break the dump.
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum KindDump {
-    DocumentImport {
-        primary_key: Option<String>,
-        method: IndexDocumentsMethod,
-        documents_count: u64,
-        allow_index_creation: bool,
-    },
-    DocumentDeletion {
-        documents_ids: Vec<String>,
-    },
-    DocumentClear,
-    Settings {
-        settings: Box<meilisearch_types::settings::Settings<Unchecked>>,
-        is_deletion: bool,
-        allow_index_creation: bool,
-    },
-    IndexDeletion,
-    IndexCreation {
-        primary_key: Option<String>,
-    },
-    IndexUpdate {
-        primary_key: Option<String>,
-    },
-    IndexSwap {
-        swaps: Vec<IndexSwap>,
-    },
-    TaskCancelation {
-        query: String,
-        tasks: RoaringBitmap,
-    },
-    TasksDeletion {
-        query: String,
-        tasks: RoaringBitmap,
-    },
-    DumpCreation {
-        keys: Vec<Key>,
-        instance_uid: Option<InstanceUid>,
-    },
-    SnapshotCreation,
-}
-
-impl From<Task> for TaskDump {
-    fn from(task: Task) -> Self {
-        TaskDump {
-            uid: task.uid,
-            index_uid: task.index_uid().map(|uid| uid.to_string()),
-            status: task.status,
-            kind: task.kind.into(),
-            canceled_by: task.canceled_by,
-            details: task.details,
-            error: task.error,
-            enqueued_at: task.enqueued_at,
-            started_at: task.started_at,
-            finished_at: task.finished_at,
-        }
-    }
-}
-
-impl From<KindWithContent> for KindDump {
-    fn from(kind: KindWithContent) -> Self {
-        match kind {
-            KindWithContent::DocumentAdditionOrUpdate {
-                primary_key,
-                method,
-                documents_count,
-                allow_index_creation,
-                ..
-            } => KindDump::DocumentImport {
-                primary_key,
-                method,
-                documents_count,
-                allow_index_creation,
-            },
-            KindWithContent::DocumentDeletion { documents_ids, .. } => {
-                KindDump::DocumentDeletion { documents_ids }
-            }
-            KindWithContent::DocumentClear { .. } => KindDump::DocumentClear,
-            KindWithContent::SettingsUpdate {
-                new_settings,
-                is_deletion,
-                allow_index_creation,
-                ..
-            } => KindDump::Settings { settings: new_settings, is_deletion, allow_index_creation },
-            KindWithContent::IndexDeletion { .. } => KindDump::IndexDeletion,
-            KindWithContent::IndexCreation { primary_key, .. } => {
-                KindDump::IndexCreation { primary_key }
-            }
-            KindWithContent::IndexUpdate { primary_key, .. } => {
-                KindDump::IndexUpdate { primary_key }
-            }
-            KindWithContent::IndexSwap { swaps } => KindDump::IndexSwap { swaps },
-            KindWithContent::TaskCancelation { query, tasks } => {
-                KindDump::TaskCancelation { query, tasks }
-            }
-            KindWithContent::TaskDeletion { query, tasks } => {
-                KindDump::TasksDeletion { query, tasks }
-            }
-            KindWithContent::DumpCreation { keys, instance_uid } => {
-                KindDump::DumpCreation { keys, instance_uid }
-            }
-            KindWithContent::SnapshotCreation => KindDump::SnapshotCreation,
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::Seek;
-    use std::str::FromStr;
-
-    use big_s::S;
-    use maplit::btreeset;
-    use meilisearch_types::index_uid::IndexUid;
-    use meilisearch_types::keys::{Action, Key};
-    use meilisearch_types::milli::update::Setting;
-    use meilisearch_types::milli::{self};
-    use meilisearch_types::settings::{Checked, Settings};
-    use meilisearch_types::star_or::StarOr;
-    use meilisearch_types::tasks::{Details, Status};
-    use serde_json::{json, Map, Value};
-    use time::macros::datetime;
-    use uuid::Uuid;
-
-    use crate::reader::Document;
-    use crate::{DumpReader, DumpWriter, IndexMetadata, KindDump, TaskDump, Version};
-
-    pub fn create_test_instance_uid() -> Uuid {
-        Uuid::parse_str("9e15e977-f2ae-4761-943f-1eaf75fd736d").unwrap()
-    }
-
-    pub fn create_test_index_metadata() -> IndexMetadata {
-        IndexMetadata {
-            uid: S("doggo"),
-            primary_key: None,
-            created_at: datetime!(2022-11-20 12:00 UTC),
-            updated_at: datetime!(2022-11-21 00:00 UTC),
-        }
-    }
-
-    pub fn create_test_documents() -> Vec<Map<String, Value>> {
-        vec![
-            json!({ "id": 1, "race": "golden retriever", "name": "paul", "age": 4 })
-                .as_object()
-                .unwrap()
-                .clone(),
-            json!({ "id": 2, "race": "bernese mountain", "name": "tamo", "age": 6 })
-                .as_object()
-                .unwrap()
-                .clone(),
-            json!({ "id": 3, "race": "great pyrenees", "name": "patou", "age": 5 })
-                .as_object()
-                .unwrap()
-                .clone(),
-        ]
-    }
-
-    pub fn create_test_settings() -> Settings<Checked> {
-        let settings = Settings {
-            displayed_attributes: Setting::Set(vec![S("race"), S("name")]),
-            searchable_attributes: Setting::Set(vec![S("name"), S("race")]),
-            filterable_attributes: Setting::Set(btreeset! { S("race"), S("age") }),
-            sortable_attributes: Setting::Set(btreeset! { S("age") }),
-            ranking_rules: Setting::NotSet,
-            stop_words: Setting::NotSet,
-            synonyms: Setting::NotSet,
-            distinct_attribute: Setting::NotSet,
-            typo_tolerance: Setting::NotSet,
-            faceting: Setting::NotSet,
-            pagination: Setting::NotSet,
-            _kind: std::marker::PhantomData,
-        };
-        settings.check()
-    }
-
-    pub fn create_test_tasks() -> Vec<(TaskDump, Option<Vec<Document>>)> {
-        vec![
-            (
-                TaskDump {
-                    uid: 0,
-                    index_uid: Some(S("doggo")),
-                    status: Status::Succeeded,
-                    kind: KindDump::DocumentImport {
-                        method: milli::update::IndexDocumentsMethod::UpdateDocuments,
-                        allow_index_creation: true,
-                        primary_key: Some(S("bone")),
-                        documents_count: 12,
-                    },
-                    canceled_by: None,
-                    details: Some(Details::DocumentAdditionOrUpdate {
-                        received_documents: 12,
-                        indexed_documents: Some(10),
-                    }),
-                    error: None,
-                    enqueued_at: datetime!(2022-11-11 0:00 UTC),
-                    started_at: Some(datetime!(2022-11-20 0:00 UTC)),
-                    finished_at: Some(datetime!(2022-11-21 0:00 UTC)),
-                },
-                None,
-            ),
-            (
-                TaskDump {
-                    uid: 1,
-                    index_uid: Some(S("doggo")),
-                    status: Status::Enqueued,
-                    kind: KindDump::DocumentImport {
-                        method: milli::update::IndexDocumentsMethod::UpdateDocuments,
-                        allow_index_creation: true,
-                        primary_key: None,
-                        documents_count: 2,
-                    },
-                    canceled_by: None,
-                    details: Some(Details::DocumentAdditionOrUpdate {
-                        received_documents: 2,
-                        indexed_documents: None,
-                    }),
-                    error: None,
-                    enqueued_at: datetime!(2022-11-11 0:00 UTC),
-                    started_at: None,
-                    finished_at: None,
-                },
-                Some(vec![
-                    json!({ "id": 4, "race": "leonberg" }).as_object().unwrap().clone(),
-                    json!({ "id": 5, "race": "patou" }).as_object().unwrap().clone(),
-                ]),
-            ),
-            (
-                TaskDump {
-                    uid: 5,
-                    index_uid: Some(S("catto")),
-                    status: Status::Enqueued,
-                    kind: KindDump::IndexDeletion,
-                    canceled_by: None,
-                    details: None,
-                    error: None,
-                    enqueued_at: datetime!(2022-11-15 0:00 UTC),
-                    started_at: None,
-                    finished_at: None,
-                },
-                None,
-            ),
-        ]
-    }
-
-    pub fn create_test_api_keys() -> Vec<Key> {
-        vec![
-            Key {
-                description: Some(S("The main key to manage all the doggos")),
-                name: Some(S("doggos_key")),
-                uid: Uuid::from_str("9f8a34da-b6b2-42f0-939b-dbd4c3448655").unwrap(),
-                actions: vec![Action::DocumentsAll],
-                indexes: vec![StarOr::Other(IndexUid::from_str("doggos").unwrap())],
-                expires_at: Some(datetime!(4130-03-14 12:21 UTC)),
-                created_at: datetime!(1960-11-15 0:00 UTC),
-                updated_at: datetime!(2022-11-10 0:00 UTC),
-            },
-            Key {
-                description: Some(S("The master key for everything and even the doggos")),
-                name: Some(S("master_key")),
-                uid: Uuid::from_str("4622f717-1c00-47bb-a494-39d76a49b591").unwrap(),
-                actions: vec![Action::All],
-                indexes: vec![StarOr::Star],
-                expires_at: None,
-                created_at: datetime!(0000-01-01 00:01 UTC),
-                updated_at: datetime!(1964-05-04 17:25 UTC),
-            },
-            Key {
-                description: Some(S("The useless key to for nothing nor the doggos")),
-                name: Some(S("useless_key")),
-                uid: Uuid::from_str("fb80b58b-0a34-412f-8ba7-1ce868f8ac5c").unwrap(),
-                actions: vec![],
-                indexes: vec![],
-                expires_at: None,
-                created_at: datetime!(400-02-29 0:00 UTC),
-                updated_at: datetime!(1024-02-29 0:00 UTC),
-            },
-        ]
-    }
-
-    pub fn create_test_dump() -> File {
-        let instance_uid = create_test_instance_uid();
-        let dump = DumpWriter::new(Some(instance_uid)).unwrap();
-
-        // ========== Adding an index
-        let documents = create_test_documents();
-        let settings = create_test_settings();
-
-        let mut index = dump.create_index("doggos", &create_test_index_metadata()).unwrap();
-        for document in &documents {
-            index.push_document(document).unwrap();
-        }
-        index.flush().unwrap();
-        index.settings(&settings).unwrap();
-
-        // ========== pushing the task queue
-        let tasks = create_test_tasks();
-
-        let mut task_queue = dump.create_tasks_queue().unwrap();
-        for (task, update_file) in &tasks {
-            let mut update = task_queue.push_task(task).unwrap();
-            if let Some(update_file) = update_file {
-                for u in update_file {
-                    update.push_document(u).unwrap();
-                }
-            }
-        }
-        task_queue.flush().unwrap();
-
-        // ========== pushing the api keys
-        let api_keys = create_test_api_keys();
-
-        let mut keys = dump.create_keys().unwrap();
-        for key in &api_keys {
-            keys.push_key(key).unwrap();
-        }
-        keys.flush().unwrap();
-
-        // create the dump
-        let mut file = tempfile::tempfile().unwrap();
-        dump.persist_to(&mut file).unwrap();
-        file.rewind().unwrap();
-
-        file
-    }
-
-    #[test]
-    fn test_creating_and_read_dump() {
-        let mut file = create_test_dump();
-        let mut dump = DumpReader::open(&mut file).unwrap();
-
-        // ==== checking the top level infos
-        assert_eq!(dump.version(), Version::V6);
-        assert!(dump.date().is_some());
-        assert_eq!(dump.instance_uid().unwrap().unwrap(), create_test_instance_uid());
-
-        // ==== checking the index
-        let mut indexes = dump.indexes().unwrap();
-        let mut index = indexes.next().unwrap().unwrap();
-        assert!(indexes.next().is_none()); // there was only one index in the dump
-
-        for (document, expected) in index.documents().unwrap().zip(create_test_documents()) {
-            assert_eq!(document.unwrap(), expected);
-        }
-        assert_eq!(index.settings().unwrap(), create_test_settings());
-        assert_eq!(index.metadata(), &create_test_index_metadata());
-
-        drop(index);
-        drop(indexes);
-
-        // ==== checking the task queue
-        for (task, expected) in dump.tasks().unwrap().zip(create_test_tasks()) {
-            let (task, content_file) = task.unwrap();
-            assert_eq!(task, expected.0);
-
-            if let Some(expected_update) = expected.1 {
-                assert!(
-                    content_file.is_some(),
-                    "A content file was expected for the task {}.",
-                    expected.0.uid
-                );
-                let updates = content_file.unwrap().collect::<Result<Vec<_>, _>>().unwrap();
-                assert_eq!(updates, expected_update);
-            }
-        }
-
-        // ==== checking the keys
-        for (key, expected) in dump.keys().unwrap().zip(create_test_api_keys()) {
-            assert_eq!(key.unwrap(), expected);
-        }
-    }
-}

dump/src/reader/compat/mod.rs

@@ -1,5 +0,0 @@
-pub mod v1_to_v2;
-pub mod v2_to_v3;
-pub mod v3_to_v4;
-pub mod v4_to_v5;
-pub mod v5_to_v6;

dump/src/reader/compat/snapshots/dump__reader__compat__v1_to_v2__test__compat_v1_v2-3.snap

@@ -1,38 +0,0 @@
----
-source: dump/src/reader/compat/v1_to_v2.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v1_to_v2__test__compat_v1_v2-6.snap

@@ -1,31 +0,0 @@
----
-source: dump/src/reader/compat/v1_to_v2.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "genres",
-    "id"
-  ],
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v1_to_v2__test__compat_v1_v2-9.snap

@@ -1,24 +0,0 @@
----
-source: dump/src/reader/compat/v1_to_v2.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v2_to_v3__test__compat_v2_v3-11.snap

@@ -1,23 +0,0 @@
----
-source: dump/src/reader/compat/v2_to_v3.rs
-expression: movies2.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v2_to_v3__test__compat_v2_v3-14.snap

@@ -1,23 +0,0 @@
----
-source: dump/src/reader/compat/v2_to_v3.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v2_to_v3__test__compat_v2_v3-5.snap

@@ -1,37 +0,0 @@
----
-source: dump/src/reader/compat/v2_to_v3.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v2_to_v3__test__compat_v2_v3-8.snap

@@ -1,24 +0,0 @@
----
-source: dump/src/reader/compat/v2_to_v3.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v3_to_v4__test__compat_v3_v4-12.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/compat/v3_to_v4.rs
-expression: movies2.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v3_to_v4__test__compat_v3_v4-15.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/compat/v3_to_v4.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v3_to_v4__test__compat_v3_v4-6.snap

@@ -1,39 +0,0 @@
----
-source: dump/src/reader/compat/v3_to_v4.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v3_to_v4__test__compat_v3_v4-9.snap

@@ -1,31 +0,0 @@
----
-source: dump/src/reader/compat/v3_to_v4.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v4_to_v5__test__compat_v4_v5-12.snap

@@ -1,56 +0,0 @@
----
-source: dump/src/reader/compat/v4_to_v5.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": "Reset",
-  "searchableAttributes": "Reset",
-  "filterableAttributes": {
-    "Set": []
-  },
-  "sortableAttributes": {
-    "Set": []
-  },
-  "rankingRules": {
-    "Set": [
-      "words",
-      "typo",
-      "proximity",
-      "attribute",
-      "sort",
-      "exactness"
-    ]
-  },
-  "stopWords": {
-    "Set": []
-  },
-  "synonyms": {
-    "Set": {}
-  },
-  "distinctAttribute": "Reset",
-  "typoTolerance": {
-    "Set": {
-      "enabled": {
-        "Set": true
-      },
-      "minWordSizeForTypos": {
-        "Set": {
-          "oneTypo": {
-            "Set": 5
-          },
-          "twoTypos": {
-            "Set": 9
-          }
-        }
-      },
-      "disableOnWords": {
-        "Set": []
-      },
-      "disableOnAttributes": {
-        "Set": []
-      }
-    }
-  },
-  "faceting": "NotSet",
-  "pagination": "NotSet"
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v4_to_v5__test__compat_v4_v5-6.snap

@@ -1,70 +0,0 @@
----
-source: dump/src/reader/compat/v4_to_v5.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": "Reset",
-  "searchableAttributes": "Reset",
-  "filterableAttributes": {
-    "Set": []
-  },
-  "sortableAttributes": {
-    "Set": []
-  },
-  "rankingRules": {
-    "Set": [
-      "words",
-      "typo",
-      "proximity",
-      "attribute",
-      "sort",
-      "exactness"
-    ]
-  },
-  "stopWords": {
-    "Set": []
-  },
-  "synonyms": {
-    "Set": {
-      "android": [
-        "phone",
-        "smartphone"
-      ],
-      "iphone": [
-        "phone",
-        "smartphone"
-      ],
-      "phone": [
-        "android",
-        "iphone",
-        "smartphone"
-      ]
-    }
-  },
-  "distinctAttribute": "Reset",
-  "typoTolerance": {
-    "Set": {
-      "enabled": {
-        "Set": true
-      },
-      "minWordSizeForTypos": {
-        "Set": {
-          "oneTypo": {
-            "Set": 5
-          },
-          "twoTypos": {
-            "Set": 9
-          }
-        }
-      },
-      "disableOnWords": {
-        "Set": []
-      },
-      "disableOnAttributes": {
-        "Set": []
-      }
-    }
-  },
-  "faceting": "NotSet",
-  "pagination": "NotSet"
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v4_to_v5__test__compat_v4_v5-9.snap

@@ -1,62 +0,0 @@
----
-source: dump/src/reader/compat/v4_to_v5.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": "Reset",
-  "searchableAttributes": "Reset",
-  "filterableAttributes": {
-    "Set": [
-      "genres",
-      "id"
-    ]
-  },
-  "sortableAttributes": {
-    "Set": [
-      "release_date"
-    ]
-  },
-  "rankingRules": {
-    "Set": [
-      "words",
-      "typo",
-      "proximity",
-      "attribute",
-      "sort",
-      "exactness",
-      "release_date:asc"
-    ]
-  },
-  "stopWords": {
-    "Set": []
-  },
-  "synonyms": {
-    "Set": {}
-  },
-  "distinctAttribute": "Reset",
-  "typoTolerance": {
-    "Set": {
-      "enabled": {
-        "Set": true
-      },
-      "minWordSizeForTypos": {
-        "Set": {
-          "oneTypo": {
-            "Set": 5
-          },
-          "twoTypos": {
-            "Set": 9
-          }
-        }
-      },
-      "disableOnWords": {
-        "Set": []
-      },
-      "disableOnAttributes": {
-        "Set": []
-      }
-    }
-  },
-  "faceting": "NotSet",
-  "pagination": "NotSet"
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v5_to_v6__test__compat_v5_v6-12.snap

@@ -1,40 +0,0 @@
----
-source: dump/src/reader/compat/v5_to_v6.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  },
-  "faceting": {
-    "maxValuesPerFacet": 100
-  },
-  "pagination": {
-    "maxTotalHits": 1000
-  }
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v5_to_v6__test__compat_v5_v6-6.snap

@@ -1,54 +0,0 @@
----
-source: dump/src/reader/compat/v5_to_v6.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  },
-  "faceting": {
-    "maxValuesPerFacet": 100
-  },
-  "pagination": {
-    "maxTotalHits": 1000
-  }
-}

dump/src/reader/compat/snapshots/dump__reader__compat__v5_to_v6__test__compat_v5_v6-9.snap

@@ -1,46 +0,0 @@
----
-source: dump/src/reader/compat/v5_to_v6.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  },
-  "faceting": {
-    "maxValuesPerFacet": 100
-  },
-  "pagination": {
-    "maxTotalHits": 1000
-  }
-}

dump/src/reader/compat/v1_to_v2.rs

@@ -1,410 +0,0 @@
-use std::str::FromStr;
-
-use super::v2_to_v3::CompatV2ToV3;
-use crate::reader::{v1, v2, Document};
-use crate::Result;
-
-pub struct CompatV1ToV2 {
-    pub from: v1::V1Reader,
-}
-
-impl CompatV1ToV2 {
-    pub fn new(v1: v1::V1Reader) -> Self {
-        Self { from: v1 }
-    }
-
-    pub fn to_v3(self) -> CompatV2ToV3 {
-        CompatV2ToV3::Compat(self)
-    }
-
-    pub fn version(&self) -> crate::Version {
-        self.from.version()
-    }
-
-    pub fn date(&self) -> Option<time::OffsetDateTime> {
-        self.from.date()
-    }
-
-    pub fn index_uuid(&self) -> Vec<v2::meta::IndexUuid> {
-        self.from
-            .index_uuid()
-            .into_iter()
-            .enumerate()
-            // we use the index of the index 😬 as UUID for the index, so that we can link the v2::Task to their index
-            .map(|(index, index_uuid)| v2::meta::IndexUuid {
-                uid: index_uuid.uid,
-                uuid: uuid::Uuid::from_u128(index as u128),
-            })
-            .collect()
-    }
-
-    pub fn indexes(&self) -> Result<impl Iterator<Item = Result<CompatIndexV1ToV2>> + '_> {
-        Ok(self.from.indexes()?.map(|index_reader| Ok(CompatIndexV1ToV2 { from: index_reader? })))
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Box<dyn Iterator<Item = Result<(v2::Task, Option<v2::UpdateFile>)>> + '_> {
-        // Convert an error here to an iterator yielding the error
-        let indexes = match self.from.indexes() {
-            Ok(indexes) => indexes,
-            Err(err) => return Box::new(std::iter::once(Err(err))),
-        };
-        let it = indexes.enumerate().flat_map(
-            move |(index, index_reader)| -> Box<dyn Iterator<Item = _>> {
-                let index_reader = match index_reader {
-                    Ok(index_reader) => index_reader,
-                    Err(err) => return Box::new(std::iter::once(Err(err))),
-                };
-                Box::new(
-                    index_reader
-                        .tasks()
-                        // Filter out the UpdateStatus::Customs variant that is not supported in v2
-                        // and enqueued tasks, that don't contain the necessary update file in v1
-                        .filter_map(move |task| -> Option<_> {
-                            let task = match task {
-                                Ok(task) => task,
-                                Err(err) => return Some(Err(err)),
-                            };
-                            Some(Ok((
-                                v2::Task {
-                                    uuid: uuid::Uuid::from_u128(index as u128),
-                                    update: Option::from(task)?,
-                                },
-                                None,
-                            )))
-                        }),
-                )
-            },
-        );
-        Box::new(it)
-    }
-}
-
-pub struct CompatIndexV1ToV2 {
-    pub from: v1::V1IndexReader,
-}
-
-impl CompatIndexV1ToV2 {
-    pub fn metadata(&self) -> &crate::IndexMetadata {
-        self.from.metadata()
-    }
-
-    pub fn documents(&mut self) -> Result<Box<dyn Iterator<Item = Result<Document>> + '_>> {
-        self.from.documents().map(|it| Box::new(it) as Box<dyn Iterator<Item = _>>)
-    }
-
-    pub fn settings(&mut self) -> Result<v2::settings::Settings<v2::settings::Checked>> {
-        Ok(v2::settings::Settings::<v2::settings::Unchecked>::from(self.from.settings()?).check())
-    }
-}
-
-impl From<v1::settings::Settings> for v2::Settings<v2::Unchecked> {
-    fn from(source: v1::settings::Settings) -> Self {
-        Self {
-            displayed_attributes: option_to_setting(source.displayed_attributes)
-                .map(|displayed| displayed.into_iter().collect()),
-            searchable_attributes: option_to_setting(source.searchable_attributes),
-            filterable_attributes: option_to_setting(source.attributes_for_faceting.clone())
-                .map(|filterable| filterable.into_iter().collect()),
-            sortable_attributes: option_to_setting(source.attributes_for_faceting)
-                .map(|sortable| sortable.into_iter().collect()),
-            ranking_rules: option_to_setting(source.ranking_rules).map(|ranking_rules| {
-                ranking_rules
-                    .into_iter()
-                    .filter_map(|ranking_rule| {
-                        match v1::settings::RankingRule::from_str(&ranking_rule) {
-                            Ok(ranking_rule) => {
-                                let criterion: Option<v2::settings::Criterion> =
-                                    ranking_rule.into();
-                                criterion.as_ref().map(ToString::to_string)
-                            }
-                            Err(()) => {
-                                log::warn!(
-                                    "Could not import the following ranking rule: `{}`.",
-                                    ranking_rule
-                                );
-                                None
-                            }
-                        }
-                    })
-                    .collect()
-            }),
-            stop_words: option_to_setting(source.stop_words),
-            synonyms: option_to_setting(source.synonyms),
-            distinct_attribute: option_to_setting(source.distinct_attribute),
-            _kind: std::marker::PhantomData,
-        }
-    }
-}
-
-fn option_to_setting<T>(opt: Option<Option<T>>) -> v2::Setting<T> {
-    match opt {
-        Some(Some(t)) => v2::Setting::Set(t),
-        None => v2::Setting::NotSet,
-        Some(None) => v2::Setting::Reset,
-    }
-}
-
-impl From<v1::update::UpdateStatus> for Option<v2::updates::UpdateStatus> {
-    fn from(source: v1::update::UpdateStatus) -> Self {
-        use v1::update::UpdateStatus as UpdateStatusV1;
-        use v2::updates::UpdateStatus as UpdateStatusV2;
-        Some(match source {
-            UpdateStatusV1::Enqueued { content } => {
-                log::warn!(
-                    "Cannot import task {} (importing enqueued tasks from v1 dumps is unsupported)",
-                    content.update_id
-                );
-                log::warn!("Task will be skipped in the queue of imported tasks.");
-
-                return None;
-            }
-            UpdateStatusV1::Failed { content } => UpdateStatusV2::Failed(v2::updates::Failed {
-                from: v2::updates::Processing {
-                    from: v2::updates::Enqueued {
-                        update_id: content.update_id,
-                        meta: Option::from(content.update_type)?,
-                        enqueued_at: content.enqueued_at,
-                        content: None,
-                    },
-                    started_processing_at: content.processed_at
-                        - std::time::Duration::from_secs_f64(content.duration),
-                },
-                error: v2::ResponseError {
-                    // error code is ignored by serialization, and so always default in deserialized v2 dumps
-                    // that's a good thing, because we don't have them in v1 dump 😅
-                    code: http::StatusCode::default(),
-                    message: content.error.unwrap_or_default(),
-                    // error codes are unchanged between v1 and v2
-                    error_code: content.error_code.unwrap_or_default(),
-                    // error types are unchanged between v1 and v2
-                    error_type: content.error_type.unwrap_or_default(),
-                    // error links are unchanged between v1 and v2
-                    error_link: content.error_link.unwrap_or_default(),
-                },
-                failed_at: content.processed_at,
-            }),
-            UpdateStatusV1::Processed { content } => {
-                UpdateStatusV2::Processed(v2::updates::Processed {
-                    success: match &content.update_type {
-                        v1::update::UpdateType::ClearAll => {
-                            v2::updates::UpdateResult::DocumentDeletion { deleted: u64::MAX }
-                        }
-                        v1::update::UpdateType::Customs => v2::updates::UpdateResult::Other,
-                        v1::update::UpdateType::DocumentsAddition { number } => {
-                            v2::updates::UpdateResult::DocumentsAddition(
-                                v2::updates::DocumentAdditionResult { nb_documents: *number },
-                            )
-                        }
-                        v1::update::UpdateType::DocumentsPartial { number } => {
-                            v2::updates::UpdateResult::DocumentsAddition(
-                                v2::updates::DocumentAdditionResult { nb_documents: *number },
-                            )
-                        }
-                        v1::update::UpdateType::DocumentsDeletion { number } => {
-                            v2::updates::UpdateResult::DocumentDeletion { deleted: *number as u64 }
-                        }
-                        v1::update::UpdateType::Settings { .. } => v2::updates::UpdateResult::Other,
-                    },
-                    processed_at: content.processed_at,
-                    from: v2::updates::Processing {
-                        from: v2::updates::Enqueued {
-                            update_id: content.update_id,
-                            meta: Option::from(content.update_type)?,
-                            enqueued_at: content.enqueued_at,
-                            content: None,
-                        },
-                        started_processing_at: content.processed_at
-                            - std::time::Duration::from_secs_f64(content.duration),
-                    },
-                })
-            }
-        })
-    }
-}
-
-impl From<v1::update::UpdateType> for Option<v2::updates::UpdateMeta> {
-    fn from(source: v1::update::UpdateType) -> Self {
-        Some(match source {
-            v1::update::UpdateType::ClearAll => v2::updates::UpdateMeta::ClearDocuments,
-            v1::update::UpdateType::Customs => {
-                log::warn!("Ignoring task with type 'Customs' that is no longer supported");
-                return None;
-            }
-            v1::update::UpdateType::DocumentsAddition { .. } => {
-                v2::updates::UpdateMeta::DocumentsAddition {
-                    method: v2::updates::IndexDocumentsMethod::ReplaceDocuments,
-                    format: v2::updates::UpdateFormat::Json,
-                    primary_key: None,
-                }
-            }
-            v1::update::UpdateType::DocumentsPartial { .. } => {
-                v2::updates::UpdateMeta::DocumentsAddition {
-                    method: v2::updates::IndexDocumentsMethod::UpdateDocuments,
-                    format: v2::updates::UpdateFormat::Json,
-                    primary_key: None,
-                }
-            }
-            v1::update::UpdateType::DocumentsDeletion { .. } => {
-                v2::updates::UpdateMeta::DeleteDocuments { ids: vec![] }
-            }
-            v1::update::UpdateType::Settings { settings } => {
-                v2::updates::UpdateMeta::Settings((*settings).into())
-            }
-        })
-    }
-}
-
-impl From<v1::settings::SettingsUpdate> for v2::Settings<v2::Unchecked> {
-    fn from(source: v1::settings::SettingsUpdate) -> Self {
-        let ranking_rules = v2::Setting::from(source.ranking_rules);
-
-        // go from the concrete types of v1 (RankingRule) to the concrete type of v2 (Criterion),
-        // and then back to string as this is what the settings manipulate
-        let ranking_rules = ranking_rules.map(|ranking_rules| {
-            ranking_rules
-                .into_iter()
-                // filter out the WordsPosition ranking rule that exists in v1 but not v2
-                .filter_map(Option::<v2::settings::Criterion>::from)
-                .map(|criterion| criterion.to_string())
-                .collect()
-        });
-
-        Self {
-            displayed_attributes: v2::Setting::from(source.displayed_attributes)
-                .map(|displayed_attributes| displayed_attributes.into_iter().collect()),
-            searchable_attributes: source.searchable_attributes.into(),
-            filterable_attributes: v2::Setting::from(source.attributes_for_faceting.clone())
-                .map(|attributes_for_faceting| attributes_for_faceting.into_iter().collect()),
-            sortable_attributes: v2::Setting::from(source.attributes_for_faceting)
-                .map(|attributes_for_faceting| attributes_for_faceting.into_iter().collect()),
-            ranking_rules,
-            stop_words: source.stop_words.into(),
-            synonyms: source.synonyms.into(),
-            distinct_attribute: source.distinct_attribute.into(),
-            _kind: std::marker::PhantomData,
-        }
-    }
-}
-
-impl From<v1::settings::RankingRule> for Option<v2::settings::Criterion> {
-    fn from(source: v1::settings::RankingRule) -> Self {
-        match source {
-            v1::settings::RankingRule::Typo => Some(v2::settings::Criterion::Typo),
-            v1::settings::RankingRule::Words => Some(v2::settings::Criterion::Words),
-            v1::settings::RankingRule::Proximity => Some(v2::settings::Criterion::Proximity),
-            v1::settings::RankingRule::Attribute => Some(v2::settings::Criterion::Attribute),
-            v1::settings::RankingRule::WordsPosition => {
-                log::warn!("Removing the 'WordsPosition' ranking rule that is no longer supported, please check the resulting ranking rules of your indexes");
-                None
-            }
-            v1::settings::RankingRule::Exactness => Some(v2::settings::Criterion::Exactness),
-            v1::settings::RankingRule::Asc(field_name) => {
-                Some(v2::settings::Criterion::Asc(field_name))
-            }
-            v1::settings::RankingRule::Desc(field_name) => {
-                Some(v2::settings::Criterion::Desc(field_name))
-            }
-        }
-    }
-}
-
-impl<T> From<v1::settings::UpdateState<T>> for v2::Setting<T> {
-    fn from(source: v1::settings::UpdateState<T>) -> Self {
-        match source {
-            v1::settings::UpdateState::Update(new_value) => v2::Setting::Set(new_value),
-            v1::settings::UpdateState::Clear => v2::Setting::Reset,
-            v1::settings::UpdateState::Nothing => v2::Setting::NotSet,
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn compat_v1_v2() {
-        let dump = File::open("tests/assets/v1.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = v1::V1Reader::open(dir).unwrap().to_v2();
-
-        // top level infos
-        assert_eq!(dump.date(), None);
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"2298010973ee98cf4670787314176a3a");
-        assert_eq!(update_files.len(), 9);
-        assert!(update_files[..].iter().all(|u| u.is_none())); // no update file in dumps v1
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "2022-10-02T13:23:39.976870431Z",
-          "updatedAt": "2022-10-02T13:27:54.353262482Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "2022-10-02T13:15:29.477512777Z",
-          "updatedAt": "2022-10-02T13:21:12.671204856Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b63dbed5bbc059f3e32bc471ae699bf5");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "2022-10-02T13:38:26.358882984Z",
-          "updatedAt": "2022-10-02T13:38:26.385609433Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"aa24c0cfc733d66c396237ad44263bed");
-    }
-}

dump/src/reader/compat/v2_to_v3.rs

@@ -1,514 +0,0 @@
-use std::convert::TryInto;
-use std::str::FromStr;
-
-use time::OffsetDateTime;
-use uuid::Uuid;
-
-use super::v1_to_v2::{CompatIndexV1ToV2, CompatV1ToV2};
-use super::v3_to_v4::CompatV3ToV4;
-use crate::reader::{v2, v3, Document};
-use crate::Result;
-
-pub enum CompatV2ToV3 {
-    V2(v2::V2Reader),
-    Compat(CompatV1ToV2),
-}
-
-impl CompatV2ToV3 {
-    pub fn new(v2: v2::V2Reader) -> CompatV2ToV3 {
-        CompatV2ToV3::V2(v2)
-    }
-
-    pub fn index_uuid(&self) -> Vec<v3::meta::IndexUuid> {
-        let v2_uuids = match self {
-            CompatV2ToV3::V2(from) => from.index_uuid(),
-            CompatV2ToV3::Compat(compat) => compat.index_uuid(),
-        };
-        v2_uuids
-            .into_iter()
-            .into_iter()
-            .map(|index| v3::meta::IndexUuid { uid: index.uid, uuid: index.uuid })
-            .collect()
-    }
-
-    pub fn to_v4(self) -> CompatV3ToV4 {
-        CompatV3ToV4::Compat(self)
-    }
-
-    pub fn version(&self) -> crate::Version {
-        match self {
-            CompatV2ToV3::V2(from) => from.version(),
-            CompatV2ToV3::Compat(compat) => compat.version(),
-        }
-    }
-
-    pub fn date(&self) -> Option<time::OffsetDateTime> {
-        match self {
-            CompatV2ToV3::V2(from) => from.date(),
-            CompatV2ToV3::Compat(compat) => compat.date(),
-        }
-    }
-
-    pub fn instance_uid(&self) -> Result<Option<uuid::Uuid>> {
-        Ok(None)
-    }
-
-    pub fn indexes(&self) -> Result<impl Iterator<Item = Result<CompatIndexV2ToV3>> + '_> {
-        Ok(match self {
-            CompatV2ToV3::V2(from) => Box::new(from.indexes()?.map(|index_reader| -> Result<_> {
-                let compat = CompatIndexV2ToV3::new(index_reader?);
-                Ok(compat)
-            }))
-                as Box<dyn Iterator<Item = Result<CompatIndexV2ToV3>> + '_>,
-            CompatV2ToV3::Compat(compat) => Box::new(compat.indexes()?.map(|index_reader| {
-                let compat = CompatIndexV2ToV3::Compat(Box::new(index_reader?));
-                Ok(compat)
-            }))
-                as Box<dyn Iterator<Item = Result<CompatIndexV2ToV3>> + '_>,
-        })
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Box<
-        dyn Iterator<Item = Result<(v3::Task, Option<Box<dyn Iterator<Item = Result<Document>>>>)>>
-            + '_,
-    > {
-        let tasks = match self {
-            CompatV2ToV3::V2(from) => from.tasks(),
-            CompatV2ToV3::Compat(compat) => compat.tasks(),
-        };
-
-        Box::new(
-            tasks
-                .map(move |task| {
-                    task.map(|(task, content_file)| {
-                        let task = v3::Task { uuid: task.uuid, update: task.update.into() };
-
-                        Some((
-                            task,
-                            content_file.map(|content_file| {
-                                Box::new(content_file) as Box<dyn Iterator<Item = Result<Document>>>
-                            }),
-                        ))
-                    })
-                })
-                .filter_map(|res| res.transpose()),
-        )
-    }
-}
-
-pub enum CompatIndexV2ToV3 {
-    V2(v2::V2IndexReader),
-    Compat(Box<CompatIndexV1ToV2>),
-}
-
-impl CompatIndexV2ToV3 {
-    pub fn new(v2: v2::V2IndexReader) -> CompatIndexV2ToV3 {
-        CompatIndexV2ToV3::V2(v2)
-    }
-
-    pub fn metadata(&self) -> &crate::IndexMetadata {
-        match self {
-            CompatIndexV2ToV3::V2(from) => from.metadata(),
-            CompatIndexV2ToV3::Compat(compat) => compat.metadata(),
-        }
-    }
-
-    pub fn documents(&mut self) -> Result<Box<dyn Iterator<Item = Result<Document>> + '_>> {
-        match self {
-            CompatIndexV2ToV3::V2(from) => from
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-            CompatIndexV2ToV3::Compat(compat) => compat.documents(),
-        }
-    }
-
-    pub fn settings(&mut self) -> Result<v3::Settings<v3::Checked>> {
-        let settings = match self {
-            CompatIndexV2ToV3::V2(from) => from.settings()?,
-            CompatIndexV2ToV3::Compat(compat) => compat.settings()?,
-        };
-        Ok(v3::Settings::<v3::Unchecked>::from(settings).check())
-    }
-}
-
-impl From<v2::updates::UpdateStatus> for v3::updates::UpdateStatus {
-    fn from(update: v2::updates::UpdateStatus) -> Self {
-        match update {
-            v2::updates::UpdateStatus::Processing(processing) => {
-                match (processing.from.meta.clone(), processing.from.content).try_into() {
-                    Ok(meta) => v3::updates::UpdateStatus::Processing(v3::updates::Processing {
-                        from: v3::updates::Enqueued {
-                            update_id: processing.from.update_id,
-                            meta,
-                            enqueued_at: processing.from.enqueued_at,
-                        },
-                        started_processing_at: processing.started_processing_at,
-                    }),
-                    Err(e) => {
-                        log::warn!("Error with task {}: {}", processing.from.update_id, e);
-                        log::warn!("Task will be marked as `Failed`.");
-                        v3::updates::UpdateStatus::Failed(v3::updates::Failed {
-                            from: v3::updates::Processing {
-                                from: v3::updates::Enqueued {
-                                    update_id: processing.from.update_id,
-                                    meta: update_from_unchecked_update_meta(processing.from.meta),
-                                    enqueued_at: processing.from.enqueued_at,
-                                },
-                                started_processing_at: processing.started_processing_at,
-                            },
-                            msg: e.to_string(),
-                            code: v3::Code::MalformedDump,
-                            failed_at: OffsetDateTime::now_utc(),
-                        })
-                    }
-                }
-            }
-            v2::updates::UpdateStatus::Enqueued(enqueued) => {
-                match (enqueued.meta.clone(), enqueued.content).try_into() {
-                    Ok(meta) => v3::updates::UpdateStatus::Enqueued(v3::updates::Enqueued {
-                        update_id: enqueued.update_id,
-                        meta,
-                        enqueued_at: enqueued.enqueued_at,
-                    }),
-                    Err(e) => {
-                        log::warn!("Error with task {}: {}", enqueued.update_id, e);
-                        log::warn!("Task will be marked as `Failed`.");
-                        v3::updates::UpdateStatus::Failed(v3::updates::Failed {
-                            from: v3::updates::Processing {
-                                from: v3::updates::Enqueued {
-                                    update_id: enqueued.update_id,
-                                    meta: update_from_unchecked_update_meta(enqueued.meta),
-                                    enqueued_at: enqueued.enqueued_at,
-                                },
-                                started_processing_at: OffsetDateTime::now_utc(),
-                            },
-                            msg: e.to_string(),
-                            code: v3::Code::MalformedDump,
-                            failed_at: OffsetDateTime::now_utc(),
-                        })
-                    }
-                }
-            }
-            v2::updates::UpdateStatus::Processed(processed) => {
-                v3::updates::UpdateStatus::Processed(v3::updates::Processed {
-                    success: processed.success.into(),
-                    processed_at: processed.processed_at,
-                    from: v3::updates::Processing {
-                        from: v3::updates::Enqueued {
-                            update_id: processed.from.from.update_id,
-                            // since we're never going to read the content_file again it's ok to generate a fake one.
-                            meta: update_from_unchecked_update_meta(processed.from.from.meta),
-                            enqueued_at: processed.from.from.enqueued_at,
-                        },
-                        started_processing_at: processed.from.started_processing_at,
-                    },
-                })
-            }
-            v2::updates::UpdateStatus::Aborted(aborted) => {
-                v3::updates::UpdateStatus::Aborted(v3::updates::Aborted {
-                    from: v3::updates::Enqueued {
-                        update_id: aborted.from.update_id,
-                        // since we're never going to read the content_file again it's ok to generate a fake one.
-                        meta: update_from_unchecked_update_meta(aborted.from.meta),
-                        enqueued_at: aborted.from.enqueued_at,
-                    },
-                    aborted_at: aborted.aborted_at,
-                })
-            }
-            v2::updates::UpdateStatus::Failed(failed) => {
-                v3::updates::UpdateStatus::Failed(v3::updates::Failed {
-                    from: v3::updates::Processing {
-                        from: v3::updates::Enqueued {
-                            update_id: failed.from.from.update_id,
-                            // since we're never going to read the content_file again it's ok to generate a fake one.
-                            meta: update_from_unchecked_update_meta(failed.from.from.meta),
-                            enqueued_at: failed.from.from.enqueued_at,
-                        },
-                        started_processing_at: failed.from.started_processing_at,
-                    },
-                    msg: failed.error.message,
-                    code: failed.error.error_code.into(),
-                    failed_at: failed.failed_at,
-                })
-            }
-        }
-    }
-}
-
-impl TryFrom<(v2::updates::UpdateMeta, Option<Uuid>)> for v3::updates::Update {
-    type Error = crate::Error;
-
-    fn try_from((update, uuid): (v2::updates::UpdateMeta, Option<Uuid>)) -> Result<Self> {
-        Ok(match update {
-            v2::updates::UpdateMeta::DocumentsAddition { method, format: _, primary_key }
-                if uuid.is_some() =>
-            {
-                v3::updates::Update::DocumentAddition {
-                    primary_key,
-                    method: match method {
-                        v2::updates::IndexDocumentsMethod::ReplaceDocuments => {
-                            v3::updates::IndexDocumentsMethod::ReplaceDocuments
-                        }
-                        v2::updates::IndexDocumentsMethod::UpdateDocuments => {
-                            v3::updates::IndexDocumentsMethod::UpdateDocuments
-                        }
-                    },
-                    content_uuid: uuid.unwrap(),
-                }
-            }
-            v2::updates::UpdateMeta::DocumentsAddition { .. } => {
-                return Err(crate::Error::MalformedTask)
-            }
-            v2::updates::UpdateMeta::ClearDocuments => v3::updates::Update::ClearDocuments,
-            v2::updates::UpdateMeta::DeleteDocuments { ids } => {
-                v3::updates::Update::DeleteDocuments(ids)
-            }
-            v2::updates::UpdateMeta::Settings(settings) => {
-                v3::updates::Update::Settings(settings.into())
-            }
-        })
-    }
-}
-
-pub fn update_from_unchecked_update_meta(update: v2::updates::UpdateMeta) -> v3::updates::Update {
-    match update {
-        v2::updates::UpdateMeta::DocumentsAddition { method, format: _, primary_key } => {
-            v3::updates::Update::DocumentAddition {
-                primary_key,
-                method: match method {
-                    v2::updates::IndexDocumentsMethod::ReplaceDocuments => {
-                        v3::updates::IndexDocumentsMethod::ReplaceDocuments
-                    }
-                    v2::updates::IndexDocumentsMethod::UpdateDocuments => {
-                        v3::updates::IndexDocumentsMethod::UpdateDocuments
-                    }
-                },
-                // we use this special uuid so we can recognize it if one day there is a bug related to this field.
-                content_uuid: Uuid::from_str("00112233-4455-6677-8899-aabbccddeeff").unwrap(),
-            }
-        }
-        v2::updates::UpdateMeta::ClearDocuments => v3::updates::Update::ClearDocuments,
-        v2::updates::UpdateMeta::DeleteDocuments { ids } => {
-            v3::updates::Update::DeleteDocuments(ids)
-        }
-        v2::updates::UpdateMeta::Settings(settings) => {
-            v3::updates::Update::Settings(settings.into())
-        }
-    }
-}
-
-impl From<v2::updates::UpdateResult> for v3::updates::UpdateResult {
-    fn from(result: v2::updates::UpdateResult) -> Self {
-        match result {
-            v2::updates::UpdateResult::DocumentsAddition(addition) => {
-                v3::updates::UpdateResult::DocumentsAddition(v3::updates::DocumentAdditionResult {
-                    nb_documents: addition.nb_documents,
-                })
-            }
-            v2::updates::UpdateResult::DocumentDeletion { deleted } => {
-                v3::updates::UpdateResult::DocumentDeletion { deleted }
-            }
-            v2::updates::UpdateResult::Other => v3::updates::UpdateResult::Other,
-        }
-    }
-}
-
-impl From<String> for v3::Code {
-    fn from(code: String) -> Self {
-        match code.as_ref() {
-            "create_index" => v3::Code::CreateIndex,
-            "index_already_exists" => v3::Code::IndexAlreadyExists,
-            "index_not_found" => v3::Code::IndexNotFound,
-            "invalid_index_uid" => v3::Code::InvalidIndexUid,
-            "invalid_state" => v3::Code::InvalidState,
-            "missing_primary_key" => v3::Code::MissingPrimaryKey,
-            "primary_key_already_present" => v3::Code::PrimaryKeyAlreadyPresent,
-            "max_fields_limit_exceeded" => v3::Code::MaxFieldsLimitExceeded,
-            "missing_document_id" => v3::Code::MissingDocumentId,
-            "invalid_document_id" => v3::Code::InvalidDocumentId,
-            "filter" => v3::Code::Filter,
-            "sort" => v3::Code::Sort,
-            "bad_parameter" => v3::Code::BadParameter,
-            "bad_request" => v3::Code::BadRequest,
-            "database_size_limit_reached" => v3::Code::DatabaseSizeLimitReached,
-            "document_not_found" => v3::Code::DocumentNotFound,
-            "internal" => v3::Code::Internal,
-            "invalid_geo_field" => v3::Code::InvalidGeoField,
-            "invalid_ranking_rule" => v3::Code::InvalidRankingRule,
-            "invalid_store" => v3::Code::InvalidStore,
-            "invalid_token" => v3::Code::InvalidToken,
-            "missing_authorization_header" => v3::Code::MissingAuthorizationHeader,
-            "no_space_left_on_device" => v3::Code::NoSpaceLeftOnDevice,
-            "dump_not_found" => v3::Code::DumpNotFound,
-            "task_not_found" => v3::Code::TaskNotFound,
-            "payload_too_large" => v3::Code::PayloadTooLarge,
-            "retrieve_document" => v3::Code::RetrieveDocument,
-            "search_documents" => v3::Code::SearchDocuments,
-            "unsupported_media_type" => v3::Code::UnsupportedMediaType,
-            "dump_already_in_progress" => v3::Code::DumpAlreadyInProgress,
-            "dump_process_failed" => v3::Code::DumpProcessFailed,
-            "invalid_content_type" => v3::Code::InvalidContentType,
-            "missing_content_type" => v3::Code::MissingContentType,
-            "malformed_payload" => v3::Code::MalformedPayload,
-            "missing_payload" => v3::Code::MissingPayload,
-            other => {
-                log::warn!("Unknown error code {}", other);
-                v3::Code::UnretrievableErrorCode
-            }
-        }
-    }
-}
-
-impl<A> From<v2::Setting<A>> for v3::Setting<A> {
-    fn from(setting: v2::Setting<A>) -> Self {
-        match setting {
-            v2::settings::Setting::Set(a) => v3::settings::Setting::Set(a),
-            v2::settings::Setting::Reset => v3::settings::Setting::Reset,
-            v2::settings::Setting::NotSet => v3::settings::Setting::NotSet,
-        }
-    }
-}
-
-impl<T> From<v2::Settings<T>> for v3::Settings<v3::Unchecked> {
-    fn from(settings: v2::Settings<T>) -> Self {
-        v3::Settings {
-            displayed_attributes: settings.displayed_attributes.into(),
-            searchable_attributes: settings.searchable_attributes.into(),
-            filterable_attributes: settings.filterable_attributes.into(),
-            sortable_attributes: settings.sortable_attributes.into(),
-            ranking_rules: v3::Setting::from(settings.ranking_rules).map(|criteria| {
-                criteria.into_iter().map(|criterion| patch_ranking_rules(&criterion)).collect()
-            }),
-            stop_words: settings.stop_words.into(),
-            synonyms: settings.synonyms.into(),
-            distinct_attribute: settings.distinct_attribute.into(),
-            _kind: std::marker::PhantomData,
-        }
-    }
-}
-
-fn patch_ranking_rules(ranking_rule: &str) -> String {
-    match v2::settings::Criterion::from_str(ranking_rule) {
-        Ok(v2::settings::Criterion::Words) => String::from("words"),
-        Ok(v2::settings::Criterion::Typo) => String::from("typo"),
-        Ok(v2::settings::Criterion::Proximity) => String::from("proximity"),
-        Ok(v2::settings::Criterion::Attribute) => String::from("attribute"),
-        Ok(v2::settings::Criterion::Sort) => String::from("sort"),
-        Ok(v2::settings::Criterion::Exactness) => String::from("exactness"),
-        Ok(v2::settings::Criterion::Asc(name)) => format!("{name}:asc"),
-        Ok(v2::settings::Criterion::Desc(name)) => format!("{name}:desc"),
-        // we want to forward the error to the current version of meilisearch
-        Err(_) => ranking_rule.to_string(),
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn compat_v2_v3() {
-        let dump = File::open("tests/assets/v2.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = v2::V2Reader::open(dir).unwrap().to_v3();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, mut update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"9507711db47c7171c79bc6d57d0bed79");
-        assert_eq!(update_files.len(), 9);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        let update_file = update_files.remove(0).unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(update_file), @"7b8889539b669c7b9ddba448bafa385d");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies2 = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d153b5a81d8b3cdcbe1dec270b574022");
-
-        // movies2
-        insta::assert_json_snapshot!(movies2.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies_2",
-          "primaryKey": null,
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies2.settings().unwrap());
-        let documents = movies2.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 0);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d751713988987e9331980363e24189ce");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-}

dump/src/reader/compat/v3_to_v4.rs

@@ -1,449 +0,0 @@
-use super::v2_to_v3::{CompatIndexV2ToV3, CompatV2ToV3};
-use super::v4_to_v5::CompatV4ToV5;
-use crate::reader::{v3, v4, UpdateFile};
-use crate::Result;
-
-pub enum CompatV3ToV4 {
-    V3(v3::V3Reader),
-    Compat(CompatV2ToV3),
-}
-
-impl CompatV3ToV4 {
-    pub fn new(v3: v3::V3Reader) -> CompatV3ToV4 {
-        CompatV3ToV4::V3(v3)
-    }
-
-    pub fn to_v5(self) -> CompatV4ToV5 {
-        CompatV4ToV5::Compat(self)
-    }
-
-    pub fn version(&self) -> crate::Version {
-        match self {
-            CompatV3ToV4::V3(v3) => v3.version(),
-            CompatV3ToV4::Compat(compat) => compat.version(),
-        }
-    }
-
-    pub fn date(&self) -> Option<time::OffsetDateTime> {
-        match self {
-            CompatV3ToV4::V3(v3) => v3.date(),
-            CompatV3ToV4::Compat(compat) => compat.date(),
-        }
-    }
-
-    pub fn instance_uid(&self) -> Result<Option<uuid::Uuid>> {
-        Ok(None)
-    }
-
-    pub fn indexes(&self) -> Result<impl Iterator<Item = Result<CompatIndexV3ToV4>> + '_> {
-        Ok(match self {
-            CompatV3ToV4::V3(v3) => {
-                Box::new(v3.indexes()?.map(|index| index.map(CompatIndexV3ToV4::from)))
-                    as Box<dyn Iterator<Item = Result<CompatIndexV3ToV4>> + '_>
-            }
-
-            CompatV3ToV4::Compat(compat) => {
-                Box::new(compat.indexes()?.map(|index| index.map(CompatIndexV3ToV4::from)))
-                    as Box<dyn Iterator<Item = Result<CompatIndexV3ToV4>> + '_>
-            }
-        })
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Box<dyn Iterator<Item = Result<(v4::Task, Option<Box<UpdateFile>>)>> + '_> {
-        let indexes = match self {
-            CompatV3ToV4::V3(v3) => v3.index_uuid(),
-            CompatV3ToV4::Compat(compat) => compat.index_uuid(),
-        };
-        let tasks = match self {
-            CompatV3ToV4::V3(v3) => v3.tasks(),
-            CompatV3ToV4::Compat(compat) => compat.tasks(),
-        };
-
-        Box::new(
-            tasks
-                // we need to override the old task ids that were generated
-                // by index in favor of a global unique incremental ID.
-                .enumerate()
-                .map(move |(task_id, task)| {
-                    task.map(|(task, content_file)| {
-                        let index_uid = indexes
-                            .iter()
-                            .find(|index| index.uuid == task.uuid)
-                            .map(|index| index.uid.clone());
-
-                        let index_uid = match index_uid {
-                            Some(uid) => uid,
-                            None => {
-                                log::warn!(
-                                    "Error while importing the update {}.",
-                                    task.update.id()
-                                );
-                                log::warn!(
-                                    "The index associated to the uuid `{}` could not be retrieved.",
-                                    task.uuid.to_string()
-                                );
-                                if task.update.is_finished() {
-                                    // we're fucking with his history but not his data, that's ok-ish.
-                                    log::warn!("The index-uuid will be set as `unknown`.");
-                                    String::from("unknown")
-                                } else {
-                                    log::warn!("The task will be ignored.");
-                                    return None;
-                                }
-                            }
-                        };
-
-                        let task = v4::Task {
-                            id: task_id as u32,
-                            index_uid: v4::meta::IndexUid(index_uid),
-                            content: match task.update.meta() {
-                                v3::Kind::DeleteDocuments(documents) => {
-                                    v4::tasks::TaskContent::DocumentDeletion(
-                                        v4::tasks::DocumentDeletion::Ids(documents.clone()),
-                                    )
-                                }
-                                v3::Kind::DocumentAddition {
-                                    primary_key,
-                                    method,
-                                    content_uuid,
-                                } => v4::tasks::TaskContent::DocumentAddition {
-                                    merge_strategy: match method {
-                                        v3::updates::IndexDocumentsMethod::ReplaceDocuments => {
-                                            v4::tasks::IndexDocumentsMethod::ReplaceDocuments
-                                        }
-                                        v3::updates::IndexDocumentsMethod::UpdateDocuments => {
-                                            v4::tasks::IndexDocumentsMethod::UpdateDocuments
-                                        }
-                                    },
-                                    primary_key: primary_key.clone(),
-                                    documents_count: 0, // we don't have this info
-                                    allow_index_creation: true, // there was no API-key in the v3
-                                    content_uuid: *content_uuid,
-                                },
-                                v3::Kind::Settings(settings) => {
-                                    v4::tasks::TaskContent::SettingsUpdate {
-                                        settings: v4::Settings::from(settings.clone()),
-                                        is_deletion: false, // that didn't exist at this time
-                                        allow_index_creation: true, // there was no API-key in the v3
-                                    }
-                                }
-                                v3::Kind::ClearDocuments => {
-                                    v4::tasks::TaskContent::DocumentDeletion(
-                                        v4::tasks::DocumentDeletion::Clear,
-                                    )
-                                }
-                            },
-                            events: match task.update {
-                                v3::Status::Processing(processing) => {
-                                    vec![v4::tasks::TaskEvent::Created(processing.from.enqueued_at)]
-                                }
-                                v3::Status::Enqueued(enqueued) => {
-                                    vec![v4::tasks::TaskEvent::Created(enqueued.enqueued_at)]
-                                }
-                                v3::Status::Processed(processed) => {
-                                    vec![
-                                        v4::tasks::TaskEvent::Created(
-                                            processed.from.from.enqueued_at,
-                                        ),
-                                        v4::tasks::TaskEvent::Processing(
-                                            processed.from.started_processing_at,
-                                        ),
-                                        v4::tasks::TaskEvent::Succeded {
-                                            result: match processed.success {
-                                                v3::updates::UpdateResult::DocumentsAddition(
-                                                    document_addition,
-                                                ) => v4::tasks::TaskResult::DocumentAddition {
-                                                    indexed_documents: document_addition
-                                                        .nb_documents
-                                                        as u64,
-                                                },
-                                                v3::updates::UpdateResult::DocumentDeletion {
-                                                    deleted,
-                                                } => v4::tasks::TaskResult::DocumentDeletion {
-                                                    deleted_documents: deleted,
-                                                },
-                                                v3::updates::UpdateResult::Other => {
-                                                    v4::tasks::TaskResult::Other
-                                                }
-                                            },
-                                            timestamp: processed.processed_at,
-                                        },
-                                    ]
-                                }
-                                v3::Status::Failed(failed) => vec![
-                                    v4::tasks::TaskEvent::Created(failed.from.from.enqueued_at),
-                                    v4::tasks::TaskEvent::Processing(
-                                        failed.from.started_processing_at,
-                                    ),
-                                    v4::tasks::TaskEvent::Failed {
-                                        error: v4::ResponseError::from_msg(
-                                            failed.msg.to_string(),
-                                            failed.code.into(),
-                                        ),
-                                        timestamp: failed.failed_at,
-                                    },
-                                ],
-                                v3::Status::Aborted(aborted) => vec![
-                            v4::tasks::TaskEvent::Created(aborted.from.enqueued_at),
-                            v4::tasks::TaskEvent::Failed {
-                                error: v4::ResponseError::from_msg(
-                                    "Task was aborted in a previous version of meilisearch."
-                                        .to_string(),
-                                    v4::errors::Code::UnretrievableErrorCode,
-                                ),
-                                timestamp: aborted.aborted_at,
-                            },
-                        ],
-                            },
-                        };
-
-                        Some((task, content_file))
-                    })
-                })
-                .filter_map(|res| res.transpose()),
-        )
-    }
-
-    pub fn keys(&mut self) -> Box<dyn Iterator<Item = Result<v4::Key>> + '_> {
-        Box::new(std::iter::empty())
-    }
-}
-
-pub enum CompatIndexV3ToV4 {
-    V3(v3::V3IndexReader),
-    Compat(CompatIndexV2ToV3),
-}
-
-impl From<v3::V3IndexReader> for CompatIndexV3ToV4 {
-    fn from(index_reader: v3::V3IndexReader) -> Self {
-        Self::V3(index_reader)
-    }
-}
-
-impl From<CompatIndexV2ToV3> for CompatIndexV3ToV4 {
-    fn from(index_reader: CompatIndexV2ToV3) -> Self {
-        Self::Compat(index_reader)
-    }
-}
-
-impl CompatIndexV3ToV4 {
-    pub fn new(v3: v3::V3IndexReader) -> CompatIndexV3ToV4 {
-        CompatIndexV3ToV4::V3(v3)
-    }
-
-    pub fn metadata(&self) -> &crate::IndexMetadata {
-        match self {
-            CompatIndexV3ToV4::V3(v3) => v3.metadata(),
-            CompatIndexV3ToV4::Compat(compat) => compat.metadata(),
-        }
-    }
-
-    pub fn documents(&mut self) -> Result<Box<dyn Iterator<Item = Result<v4::Document>> + '_>> {
-        match self {
-            CompatIndexV3ToV4::V3(v3) => v3
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<v4::Document>> + '_>),
-
-            CompatIndexV3ToV4::Compat(compat) => compat
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<v4::Document>> + '_>),
-        }
-    }
-
-    pub fn settings(&mut self) -> Result<v4::Settings<v4::Checked>> {
-        Ok(match self {
-            CompatIndexV3ToV4::V3(v3) => {
-                v4::Settings::<v4::Unchecked>::from(v3.settings()?).check()
-            }
-            CompatIndexV3ToV4::Compat(compat) => {
-                v4::Settings::<v4::Unchecked>::from(compat.settings()?).check()
-            }
-        })
-    }
-}
-
-impl<T> From<v3::Setting<T>> for v4::Setting<T> {
-    fn from(setting: v3::Setting<T>) -> Self {
-        match setting {
-            v3::Setting::Set(t) => v4::Setting::Set(t),
-            v3::Setting::Reset => v4::Setting::Reset,
-            v3::Setting::NotSet => v4::Setting::NotSet,
-        }
-    }
-}
-
-impl From<v3::Code> for v4::Code {
-    fn from(code: v3::Code) -> Self {
-        match code {
-            v3::Code::CreateIndex => v4::Code::CreateIndex,
-            v3::Code::IndexAlreadyExists => v4::Code::IndexAlreadyExists,
-            v3::Code::IndexNotFound => v4::Code::IndexNotFound,
-            v3::Code::InvalidIndexUid => v4::Code::InvalidIndexUid,
-            v3::Code::InvalidState => v4::Code::InvalidState,
-            v3::Code::MissingPrimaryKey => v4::Code::MissingPrimaryKey,
-            v3::Code::PrimaryKeyAlreadyPresent => v4::Code::PrimaryKeyAlreadyPresent,
-            v3::Code::MaxFieldsLimitExceeded => v4::Code::MaxFieldsLimitExceeded,
-            v3::Code::MissingDocumentId => v4::Code::MissingDocumentId,
-            v3::Code::InvalidDocumentId => v4::Code::InvalidDocumentId,
-            v3::Code::Filter => v4::Code::Filter,
-            v3::Code::Sort => v4::Code::Sort,
-            v3::Code::BadParameter => v4::Code::BadParameter,
-            v3::Code::BadRequest => v4::Code::BadRequest,
-            v3::Code::DatabaseSizeLimitReached => v4::Code::DatabaseSizeLimitReached,
-            v3::Code::DocumentNotFound => v4::Code::DocumentNotFound,
-            v3::Code::Internal => v4::Code::Internal,
-            v3::Code::InvalidGeoField => v4::Code::InvalidGeoField,
-            v3::Code::InvalidRankingRule => v4::Code::InvalidRankingRule,
-            v3::Code::InvalidStore => v4::Code::InvalidStore,
-            v3::Code::InvalidToken => v4::Code::InvalidToken,
-            v3::Code::MissingAuthorizationHeader => v4::Code::MissingAuthorizationHeader,
-            v3::Code::NoSpaceLeftOnDevice => v4::Code::NoSpaceLeftOnDevice,
-            v3::Code::DumpNotFound => v4::Code::DumpNotFound,
-            v3::Code::TaskNotFound => v4::Code::TaskNotFound,
-            v3::Code::PayloadTooLarge => v4::Code::PayloadTooLarge,
-            v3::Code::RetrieveDocument => v4::Code::RetrieveDocument,
-            v3::Code::SearchDocuments => v4::Code::SearchDocuments,
-            v3::Code::UnsupportedMediaType => v4::Code::UnsupportedMediaType,
-            v3::Code::DumpAlreadyInProgress => v4::Code::DumpAlreadyInProgress,
-            v3::Code::DumpProcessFailed => v4::Code::DumpProcessFailed,
-            v3::Code::InvalidContentType => v4::Code::InvalidContentType,
-            v3::Code::MissingContentType => v4::Code::MissingContentType,
-            v3::Code::MalformedPayload => v4::Code::MalformedPayload,
-            v3::Code::MissingPayload => v4::Code::MissingPayload,
-            v3::Code::UnretrievableErrorCode => v4::Code::UnretrievableErrorCode,
-            v3::Code::MalformedDump => v4::Code::MalformedDump,
-        }
-    }
-}
-
-impl<T> From<v3::Settings<T>> for v4::Settings<v4::Unchecked> {
-    fn from(settings: v3::Settings<T>) -> Self {
-        v4::Settings {
-            displayed_attributes: settings.displayed_attributes.into(),
-            searchable_attributes: settings.searchable_attributes.into(),
-            filterable_attributes: settings.filterable_attributes.into(),
-            sortable_attributes: settings.sortable_attributes.into(),
-            ranking_rules: settings.ranking_rules.into(),
-            stop_words: settings.stop_words.into(),
-            synonyms: settings.synonyms.into(),
-            distinct_attribute: settings.distinct_attribute.into(),
-            typo_tolerance: v4::Setting::NotSet,
-            _kind: std::marker::PhantomData,
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn compat_v3_v4() {
-        let dump = File::open("tests/assets/v3.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = v3::V3Reader::open(dir).unwrap().to_v4();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, mut update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"79bc053583a1a7172bbaaafb1edaeb78");
-        assert_eq!(update_files.len(), 10);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        let update_file = update_files.remove(0).unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(update_file), @"7b8889539b669c7b9ddba448bafa385d");
-
-        // keys
-        let keys = dump.keys().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys, { "[].uid" => "[uuid]" }), @"d751713988987e9331980363e24189ce");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies2 = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d153b5a81d8b3cdcbe1dec270b574022");
-
-        // movies2
-        insta::assert_json_snapshot!(movies2.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies_2",
-          "primaryKey": null,
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies2.settings().unwrap());
-        let documents = movies2.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 0);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d751713988987e9331980363e24189ce");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-}

dump/src/reader/compat/v4_to_v5.rs

@@ -1,467 +0,0 @@
-use super::v3_to_v4::{CompatIndexV3ToV4, CompatV3ToV4};
-use super::v5_to_v6::CompatV5ToV6;
-use crate::reader::{v4, v5, Document};
-use crate::Result;
-
-pub enum CompatV4ToV5 {
-    V4(v4::V4Reader),
-    Compat(CompatV3ToV4),
-}
-
-impl CompatV4ToV5 {
-    pub fn new(v4: v4::V4Reader) -> CompatV4ToV5 {
-        CompatV4ToV5::V4(v4)
-    }
-
-    pub fn to_v6(self) -> CompatV5ToV6 {
-        CompatV5ToV6::Compat(self)
-    }
-
-    pub fn version(&self) -> crate::Version {
-        match self {
-            CompatV4ToV5::V4(v4) => v4.version(),
-            CompatV4ToV5::Compat(compat) => compat.version(),
-        }
-    }
-
-    pub fn date(&self) -> Option<time::OffsetDateTime> {
-        match self {
-            CompatV4ToV5::V4(v4) => v4.date(),
-            CompatV4ToV5::Compat(compat) => compat.date(),
-        }
-    }
-
-    pub fn instance_uid(&self) -> Result<Option<uuid::Uuid>> {
-        match self {
-            CompatV4ToV5::V4(v4) => v4.instance_uid(),
-            CompatV4ToV5::Compat(compat) => compat.instance_uid(),
-        }
-    }
-
-    pub fn indexes(&self) -> Result<Box<dyn Iterator<Item = Result<CompatIndexV4ToV5>> + '_>> {
-        Ok(match self {
-            CompatV4ToV5::V4(v4) => {
-                Box::new(v4.indexes()?.map(|index| index.map(CompatIndexV4ToV5::from)))
-                    as Box<dyn Iterator<Item = Result<CompatIndexV4ToV5>> + '_>
-            }
-
-            CompatV4ToV5::Compat(compat) => {
-                Box::new(compat.indexes()?.map(|index| index.map(CompatIndexV4ToV5::from)))
-                    as Box<dyn Iterator<Item = Result<CompatIndexV4ToV5>> + '_>
-            }
-        })
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Box<dyn Iterator<Item = Result<(v5::Task, Option<Box<crate::reader::UpdateFile>>)>> + '_>
-    {
-        let tasks = match self {
-            CompatV4ToV5::V4(v4) => v4.tasks(),
-            CompatV4ToV5::Compat(compat) => compat.tasks(),
-        };
-        Box::new(tasks.map(|task| {
-            task.map(|(task, content_file)| {
-                let task = v5::Task {
-                    id: task.id,
-                    content: match task.content {
-                        v4::tasks::TaskContent::DocumentAddition {
-                            content_uuid,
-                            merge_strategy,
-                            primary_key,
-                            documents_count,
-                            allow_index_creation,
-                        } => v5::tasks::TaskContent::DocumentAddition {
-                            index_uid: v5::meta::IndexUid(task.index_uid.0),
-                            content_uuid,
-                            merge_strategy: match merge_strategy {
-                                v4::tasks::IndexDocumentsMethod::ReplaceDocuments => {
-                                    v5::tasks::IndexDocumentsMethod::ReplaceDocuments
-                                }
-                                v4::tasks::IndexDocumentsMethod::UpdateDocuments => {
-                                    v5::tasks::IndexDocumentsMethod::UpdateDocuments
-                                }
-                            },
-                            primary_key,
-                            documents_count,
-                            allow_index_creation,
-                        },
-                        v4::tasks::TaskContent::DocumentDeletion(deletion) => {
-                            v5::tasks::TaskContent::DocumentDeletion {
-                                index_uid: v5::meta::IndexUid(task.index_uid.0),
-                                deletion: match deletion {
-                                    v4::tasks::DocumentDeletion::Clear => {
-                                        v5::tasks::DocumentDeletion::Clear
-                                    }
-                                    v4::tasks::DocumentDeletion::Ids(ids) => {
-                                        v5::tasks::DocumentDeletion::Ids(ids)
-                                    }
-                                },
-                            }
-                        }
-                        v4::tasks::TaskContent::SettingsUpdate {
-                            settings,
-                            is_deletion,
-                            allow_index_creation,
-                        } => v5::tasks::TaskContent::SettingsUpdate {
-                            index_uid: v5::meta::IndexUid(task.index_uid.0),
-                            settings: settings.into(),
-                            is_deletion,
-                            allow_index_creation,
-                        },
-                        v4::tasks::TaskContent::IndexDeletion => {
-                            v5::tasks::TaskContent::IndexDeletion {
-                                index_uid: v5::meta::IndexUid(task.index_uid.0),
-                            }
-                        }
-                        v4::tasks::TaskContent::IndexCreation { primary_key } => {
-                            v5::tasks::TaskContent::IndexCreation {
-                                index_uid: v5::meta::IndexUid(task.index_uid.0),
-                                primary_key,
-                            }
-                        }
-                        v4::tasks::TaskContent::IndexUpdate { primary_key } => {
-                            v5::tasks::TaskContent::IndexUpdate {
-                                index_uid: v5::meta::IndexUid(task.index_uid.0),
-                                primary_key,
-                            }
-                        }
-                    },
-                    events: task
-                        .events
-                        .into_iter()
-                        .map(|event| match event {
-                            v4::tasks::TaskEvent::Created(date) => {
-                                v5::tasks::TaskEvent::Created(date)
-                            }
-                            v4::tasks::TaskEvent::Batched { timestamp, batch_id } => {
-                                v5::tasks::TaskEvent::Batched { timestamp, batch_id }
-                            }
-                            v4::tasks::TaskEvent::Processing(date) => {
-                                v5::tasks::TaskEvent::Processing(date)
-                            }
-                            v4::tasks::TaskEvent::Succeded { result, timestamp } => {
-                                v5::tasks::TaskEvent::Succeeded {
-                                    result: match result {
-                                        v4::tasks::TaskResult::DocumentAddition {
-                                            indexed_documents,
-                                        } => v5::tasks::TaskResult::DocumentAddition {
-                                            indexed_documents,
-                                        },
-                                        v4::tasks::TaskResult::DocumentDeletion {
-                                            deleted_documents,
-                                        } => v5::tasks::TaskResult::DocumentDeletion {
-                                            deleted_documents,
-                                        },
-                                        v4::tasks::TaskResult::ClearAll { deleted_documents } => {
-                                            v5::tasks::TaskResult::ClearAll { deleted_documents }
-                                        }
-                                        v4::tasks::TaskResult::Other => {
-                                            v5::tasks::TaskResult::Other
-                                        }
-                                    },
-                                    timestamp,
-                                }
-                            }
-                            v4::tasks::TaskEvent::Failed { error, timestamp } => {
-                                v5::tasks::TaskEvent::Failed {
-                                    error: v5::ResponseError::from(error),
-                                    timestamp,
-                                }
-                            }
-                        })
-                        .collect(),
-                };
-
-                (task, content_file)
-            })
-        }))
-    }
-
-    pub fn keys(&mut self) -> Box<dyn Iterator<Item = Result<v5::Key>> + '_> {
-        let keys = match self {
-            CompatV4ToV5::V4(v4) => v4.keys(),
-            CompatV4ToV5::Compat(compat) => compat.keys(),
-        };
-        Box::new(keys.map(|key| {
-            key.map(|key| v5::Key {
-                description: key.description,
-                name: None,
-                uid: v5::keys::KeyId::new_v4(),
-                actions: key.actions.into_iter().filter_map(|action| action.into()).collect(),
-                indexes: key
-                    .indexes
-                    .into_iter()
-                    .map(|index| match index.as_str() {
-                        "*" => v5::StarOr::Star,
-                        _ => v5::StarOr::Other(v5::meta::IndexUid(index)),
-                    })
-                    .collect(),
-                expires_at: key.expires_at,
-                created_at: key.created_at,
-                updated_at: key.updated_at,
-            })
-        }))
-    }
-}
-
-pub enum CompatIndexV4ToV5 {
-    V4(v4::V4IndexReader),
-    Compat(CompatIndexV3ToV4),
-}
-
-impl From<v4::V4IndexReader> for CompatIndexV4ToV5 {
-    fn from(index_reader: v4::V4IndexReader) -> Self {
-        Self::V4(index_reader)
-    }
-}
-
-impl From<CompatIndexV3ToV4> for CompatIndexV4ToV5 {
-    fn from(index_reader: CompatIndexV3ToV4) -> Self {
-        Self::Compat(index_reader)
-    }
-}
-
-impl CompatIndexV4ToV5 {
-    pub fn metadata(&self) -> &crate::IndexMetadata {
-        match self {
-            CompatIndexV4ToV5::V4(v4) => v4.metadata(),
-            CompatIndexV4ToV5::Compat(compat) => compat.metadata(),
-        }
-    }
-
-    pub fn documents(&mut self) -> Result<Box<dyn Iterator<Item = Result<Document>> + '_>> {
-        match self {
-            CompatIndexV4ToV5::V4(v4) => v4
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-            CompatIndexV4ToV5::Compat(compat) => compat
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-        }
-    }
-
-    pub fn settings(&mut self) -> Result<v5::Settings<v5::Checked>> {
-        match self {
-            CompatIndexV4ToV5::V4(v4) => Ok(v5::Settings::from(v4.settings()?).check()),
-            CompatIndexV4ToV5::Compat(compat) => Ok(v5::Settings::from(compat.settings()?).check()),
-        }
-    }
-}
-
-impl<T> From<v4::Setting<T>> for v5::Setting<T> {
-    fn from(setting: v4::Setting<T>) -> Self {
-        match setting {
-            v4::Setting::Set(t) => v5::Setting::Set(t),
-            v4::Setting::Reset => v5::Setting::Reset,
-            v4::Setting::NotSet => v5::Setting::NotSet,
-        }
-    }
-}
-
-impl From<v4::ResponseError> for v5::ResponseError {
-    fn from(error: v4::ResponseError) -> Self {
-        let code = match error.error_code.as_ref() {
-            "index_creation_failed" => v5::Code::CreateIndex,
-            "index_already_exists" => v5::Code::IndexAlreadyExists,
-            "index_not_found" => v5::Code::IndexNotFound,
-            "invalid_index_uid" => v5::Code::InvalidIndexUid,
-            "invalid_min_word_length_for_typo" => v5::Code::InvalidMinWordLengthForTypo,
-            "invalid_state" => v5::Code::InvalidState,
-            "primary_key_inference_failed" => v5::Code::MissingPrimaryKey,
-            "index_primary_key_already_exists" => v5::Code::PrimaryKeyAlreadyPresent,
-            "max_fields_limit_exceeded" => v5::Code::MaxFieldsLimitExceeded,
-            "missing_document_id" => v5::Code::MissingDocumentId,
-            "invalid_document_id" => v5::Code::InvalidDocumentId,
-            "invalid_filter" => v5::Code::Filter,
-            "invalid_sort" => v5::Code::Sort,
-            "bad_parameter" => v5::Code::BadParameter,
-            "bad_request" => v5::Code::BadRequest,
-            "database_size_limit_reached" => v5::Code::DatabaseSizeLimitReached,
-            "document_not_found" => v5::Code::DocumentNotFound,
-            "internal" => v5::Code::Internal,
-            "invalid_geo_field" => v5::Code::InvalidGeoField,
-            "invalid_ranking_rule" => v5::Code::InvalidRankingRule,
-            "invalid_store_file" => v5::Code::InvalidStore,
-            "invalid_api_key" => v5::Code::InvalidToken,
-            "missing_authorization_header" => v5::Code::MissingAuthorizationHeader,
-            "no_space_left_on_device" => v5::Code::NoSpaceLeftOnDevice,
-            "dump_not_found" => v5::Code::DumpNotFound,
-            "task_not_found" => v5::Code::TaskNotFound,
-            "payload_too_large" => v5::Code::PayloadTooLarge,
-            "unretrievable_document" => v5::Code::RetrieveDocument,
-            "search_error" => v5::Code::SearchDocuments,
-            "unsupported_media_type" => v5::Code::UnsupportedMediaType,
-            "dump_already_processing" => v5::Code::DumpAlreadyInProgress,
-            "dump_process_failed" => v5::Code::DumpProcessFailed,
-            "invalid_content_type" => v5::Code::InvalidContentType,
-            "missing_content_type" => v5::Code::MissingContentType,
-            "malformed_payload" => v5::Code::MalformedPayload,
-            "missing_payload" => v5::Code::MissingPayload,
-            "api_key_not_found" => v5::Code::ApiKeyNotFound,
-            "missing_parameter" => v5::Code::MissingParameter,
-            "invalid_api_key_actions" => v5::Code::InvalidApiKeyActions,
-            "invalid_api_key_indexes" => v5::Code::InvalidApiKeyIndexes,
-            "invalid_api_key_expires_at" => v5::Code::InvalidApiKeyExpiresAt,
-            "invalid_api_key_description" => v5::Code::InvalidApiKeyDescription,
-            other => {
-                log::warn!("Unknown error code {}", other);
-                v5::Code::UnretrievableErrorCode
-            }
-        };
-        v5::ResponseError::from_msg(error.message, code)
-    }
-}
-
-impl<T> From<v4::Settings<T>> for v5::Settings<v5::Unchecked> {
-    fn from(settings: v4::Settings<T>) -> Self {
-        v5::Settings {
-            displayed_attributes: settings.displayed_attributes.into(),
-            searchable_attributes: settings.searchable_attributes.into(),
-            filterable_attributes: settings.filterable_attributes.into(),
-            sortable_attributes: settings.sortable_attributes.into(),
-            ranking_rules: settings.ranking_rules.into(),
-            stop_words: settings.stop_words.into(),
-            synonyms: settings.synonyms.into(),
-            distinct_attribute: settings.distinct_attribute.into(),
-            typo_tolerance: match settings.typo_tolerance {
-                v4::Setting::Set(typo) => v5::Setting::Set(v5::TypoTolerance {
-                    enabled: typo.enabled.into(),
-                    min_word_size_for_typos: match typo.min_word_size_for_typos {
-                        v4::Setting::Set(t) => v5::Setting::Set(v5::MinWordSizeForTypos {
-                            one_typo: t.one_typo.into(),
-                            two_typos: t.two_typos.into(),
-                        }),
-                        v4::Setting::Reset => v5::Setting::Reset,
-                        v4::Setting::NotSet => v5::Setting::NotSet,
-                    },
-                    disable_on_words: typo.disable_on_words.into(),
-                    disable_on_attributes: typo.disable_on_attributes.into(),
-                }),
-                v4::Setting::Reset => v5::Setting::Reset,
-                v4::Setting::NotSet => v5::Setting::NotSet,
-            },
-            faceting: v5::Setting::NotSet,
-            pagination: v5::Setting::NotSet,
-            _kind: std::marker::PhantomData,
-        }
-    }
-}
-
-impl From<v4::Action> for Option<v5::Action> {
-    fn from(key: v4::Action) -> Self {
-        match key {
-            v4::Action::All => Some(v5::Action::All),
-            v4::Action::Search => Some(v5::Action::Search),
-            v4::Action::DocumentsAdd => Some(v5::Action::DocumentsAdd),
-            v4::Action::DocumentsGet => Some(v5::Action::DocumentsGet),
-            v4::Action::DocumentsDelete => Some(v5::Action::DocumentsDelete),
-            v4::Action::IndexesAdd => Some(v5::Action::IndexesAdd),
-            v4::Action::IndexesGet => Some(v5::Action::IndexesGet),
-            v4::Action::IndexesUpdate => Some(v5::Action::IndexesUpdate),
-            v4::Action::IndexesDelete => Some(v5::Action::IndexesDelete),
-            v4::Action::TasksGet => Some(v5::Action::TasksGet),
-            v4::Action::SettingsGet => Some(v5::Action::SettingsGet),
-            v4::Action::SettingsUpdate => Some(v5::Action::SettingsUpdate),
-            v4::Action::StatsGet => Some(v5::Action::StatsGet),
-            v4::Action::DumpsCreate => Some(v5::Action::DumpsCreate),
-            v4::Action::DumpsGet => None,
-            v4::Action::Version => Some(v5::Action::Version),
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn compat_v4_v5() {
-        let dump = File::open("tests/assets/v4.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = v4::V4Reader::open(dir).unwrap().to_v5();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"ed9a30cded4c046ef46f7cff7450347e");
-        assert_eq!(update_files.len(), 10);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys, { "[].uid" => "[uuid]" }), @"1384361d734fd77c23804c9696228660");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"786022a66ecb992c8a2a60fee070a5ab");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-}

dump/src/reader/compat/v5_to_v6.rs

@@ -1,507 +0,0 @@
-use std::str::FromStr;
-
-use super::v4_to_v5::{CompatIndexV4ToV5, CompatV4ToV5};
-use crate::reader::{v5, v6, Document, UpdateFile};
-use crate::Result;
-
-pub enum CompatV5ToV6 {
-    V5(v5::V5Reader),
-    Compat(CompatV4ToV5),
-}
-
-impl CompatV5ToV6 {
-    pub fn new_v5(v5: v5::V5Reader) -> CompatV5ToV6 {
-        CompatV5ToV6::V5(v5)
-    }
-
-    pub fn version(&self) -> crate::Version {
-        match self {
-            CompatV5ToV6::V5(v5) => v5.version(),
-            CompatV5ToV6::Compat(compat) => compat.version(),
-        }
-    }
-
-    pub fn date(&self) -> Option<time::OffsetDateTime> {
-        match self {
-            CompatV5ToV6::V5(v5) => v5.date(),
-            CompatV5ToV6::Compat(compat) => compat.date(),
-        }
-    }
-
-    pub fn instance_uid(&self) -> Result<Option<uuid::Uuid>> {
-        match self {
-            CompatV5ToV6::V5(v5) => v5.instance_uid(),
-            CompatV5ToV6::Compat(compat) => compat.instance_uid(),
-        }
-    }
-
-    pub fn indexes(&self) -> Result<Box<dyn Iterator<Item = Result<CompatIndexV5ToV6>> + '_>> {
-        let indexes = match self {
-            CompatV5ToV6::V5(v5) => {
-                Box::new(v5.indexes()?.map(|index| index.map(CompatIndexV5ToV6::from)))
-                    as Box<dyn Iterator<Item = Result<CompatIndexV5ToV6>> + '_>
-            }
-
-            CompatV5ToV6::Compat(compat) => {
-                Box::new(compat.indexes()?.map(|index| index.map(CompatIndexV5ToV6::from)))
-                    as Box<dyn Iterator<Item = Result<CompatIndexV5ToV6>> + '_>
-            }
-        };
-        Ok(indexes)
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Result<Box<dyn Iterator<Item = Result<(v6::Task, Option<Box<UpdateFile>>)>> + '_>> {
-        let instance_uid = self.instance_uid().ok().flatten();
-        let keys = self.keys()?.collect::<Result<Vec<_>>>()?;
-
-        let tasks = match self {
-            CompatV5ToV6::V5(v5) => v5.tasks(),
-            CompatV5ToV6::Compat(compat) => compat.tasks(),
-        };
-        Ok(Box::new(tasks.map(move |task| {
-            task.map(|(task, content_file)| {
-                let mut task_view: v5::tasks::TaskView = task.clone().into();
-
-                if task_view.status == v5::Status::Processing {
-                    task_view.started_at = None;
-                }
-
-                let task = v6::Task {
-                    uid: task_view.uid,
-                    index_uid: task_view.index_uid,
-                    status: match task_view.status {
-                        v5::Status::Enqueued => v6::Status::Enqueued,
-                        v5::Status::Processing => v6::Status::Enqueued,
-                        v5::Status::Succeeded => v6::Status::Succeeded,
-                        v5::Status::Failed => v6::Status::Failed,
-                    },
-                    kind: match task.content {
-                        v5::tasks::TaskContent::IndexCreation { primary_key, .. } => {
-                            v6::Kind::IndexCreation { primary_key }
-                        }
-                        v5::tasks::TaskContent::IndexUpdate { primary_key, .. } => {
-                            v6::Kind::IndexUpdate { primary_key }
-                        }
-                        v5::tasks::TaskContent::IndexDeletion { .. } => v6::Kind::IndexDeletion,
-                        v5::tasks::TaskContent::DocumentAddition {
-                            merge_strategy,
-                            allow_index_creation,
-                            primary_key,
-                            documents_count,
-                            ..
-                        } => v6::Kind::DocumentImport {
-                            primary_key,
-                            documents_count: documents_count as u64,
-                            method: match merge_strategy {
-                                v5::tasks::IndexDocumentsMethod::ReplaceDocuments => {
-                                    v6::milli::update::IndexDocumentsMethod::ReplaceDocuments
-                                }
-                                v5::tasks::IndexDocumentsMethod::UpdateDocuments => {
-                                    v6::milli::update::IndexDocumentsMethod::UpdateDocuments
-                                }
-                            },
-                            allow_index_creation,
-                        },
-                        v5::tasks::TaskContent::DocumentDeletion { deletion, .. } => match deletion
-                        {
-                            v5::tasks::DocumentDeletion::Clear => v6::Kind::DocumentClear,
-                            v5::tasks::DocumentDeletion::Ids(documents_ids) => {
-                                v6::Kind::DocumentDeletion { documents_ids }
-                            }
-                        },
-                        v5::tasks::TaskContent::SettingsUpdate {
-                            allow_index_creation,
-                            is_deletion,
-                            settings,
-                            ..
-                        } => v6::Kind::Settings {
-                            is_deletion,
-                            allow_index_creation,
-                            settings: Box::new(settings.into()),
-                        },
-                        v5::tasks::TaskContent::Dump { uid: _ } => {
-                            // in v6 we compute the dump_uid from the started_at processing time
-                            v6::Kind::DumpCreation { keys: keys.clone(), instance_uid }
-                        }
-                    },
-                    canceled_by: None,
-                    details: task_view.details.map(|details| match details {
-                        v5::Details::DocumentAddition { received_documents, indexed_documents } => {
-                            v6::Details::DocumentAdditionOrUpdate {
-                                received_documents: received_documents as u64,
-                                indexed_documents,
-                            }
-                        }
-                        v5::Details::Settings { settings } => {
-                            v6::Details::SettingsUpdate { settings: Box::new(settings.into()) }
-                        }
-                        v5::Details::IndexInfo { primary_key } => {
-                            v6::Details::IndexInfo { primary_key }
-                        }
-                        v5::Details::DocumentDeletion {
-                            received_document_ids,
-                            deleted_documents,
-                        } => v6::Details::DocumentDeletion {
-                            provided_ids: received_document_ids,
-                            deleted_documents,
-                        },
-                        v5::Details::ClearAll { deleted_documents } => {
-                            v6::Details::ClearAll { deleted_documents }
-                        }
-                        v5::Details::Dump { dump_uid } => {
-                            v6::Details::Dump { dump_uid: Some(dump_uid) }
-                        }
-                    }),
-                    error: task_view.error.map(|e| e.into()),
-                    enqueued_at: task_view.enqueued_at,
-                    started_at: task_view.started_at,
-                    finished_at: task_view.finished_at,
-                };
-
-                (task, content_file)
-            })
-        })))
-    }
-
-    pub fn keys(&mut self) -> Result<Box<dyn Iterator<Item = Result<v6::Key>> + '_>> {
-        let keys = match self {
-            CompatV5ToV6::V5(v5) => v5.keys()?,
-            CompatV5ToV6::Compat(compat) => compat.keys(),
-        };
-
-        Ok(Box::new(keys.map(|key| {
-            key.map(|key| v6::Key {
-                description: key.description,
-                name: key.name,
-                uid: key.uid,
-                actions: key.actions.into_iter().map(|action| action.into()).collect(),
-                indexes: key
-                    .indexes
-                    .into_iter()
-                    .map(|index| match index {
-                        v5::StarOr::Star => v6::StarOr::Star,
-                        v5::StarOr::Other(uid) => {
-                            v6::StarOr::Other(v6::IndexUid::new_unchecked(uid.as_str()))
-                        }
-                    })
-                    .collect(),
-                expires_at: key.expires_at,
-                created_at: key.created_at,
-                updated_at: key.updated_at,
-            })
-        })))
-    }
-}
-
-pub enum CompatIndexV5ToV6 {
-    V5(v5::V5IndexReader),
-    Compat(CompatIndexV4ToV5),
-}
-
-impl From<v5::V5IndexReader> for CompatIndexV5ToV6 {
-    fn from(index_reader: v5::V5IndexReader) -> Self {
-        Self::V5(index_reader)
-    }
-}
-
-impl From<CompatIndexV4ToV5> for CompatIndexV5ToV6 {
-    fn from(index_reader: CompatIndexV4ToV5) -> Self {
-        Self::Compat(index_reader)
-    }
-}
-
-impl CompatIndexV5ToV6 {
-    pub fn new_v5(v5: v5::V5IndexReader) -> CompatIndexV5ToV6 {
-        CompatIndexV5ToV6::V5(v5)
-    }
-
-    pub fn metadata(&self) -> &crate::IndexMetadata {
-        match self {
-            CompatIndexV5ToV6::V5(v5) => v5.metadata(),
-            CompatIndexV5ToV6::Compat(compat) => compat.metadata(),
-        }
-    }
-
-    pub fn documents(&mut self) -> Result<Box<dyn Iterator<Item = Result<Document>> + '_>> {
-        match self {
-            CompatIndexV5ToV6::V5(v5) => v5
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-            CompatIndexV5ToV6::Compat(compat) => compat
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-        }
-    }
-
-    pub fn settings(&mut self) -> Result<v6::Settings<v6::Checked>> {
-        match self {
-            CompatIndexV5ToV6::V5(v5) => Ok(v6::Settings::from(v5.settings()?).check()),
-            CompatIndexV5ToV6::Compat(compat) => Ok(v6::Settings::from(compat.settings()?).check()),
-        }
-    }
-}
-
-impl<T> From<v5::Setting<T>> for v6::Setting<T> {
-    fn from(setting: v5::Setting<T>) -> Self {
-        match setting {
-            v5::Setting::Set(t) => v6::Setting::Set(t),
-            v5::Setting::Reset => v6::Setting::Reset,
-            v5::Setting::NotSet => v6::Setting::NotSet,
-        }
-    }
-}
-
-impl From<v5::ResponseError> for v6::ResponseError {
-    fn from(error: v5::ResponseError) -> Self {
-        let code = match error.error_code.as_ref() {
-            "index_creation_failed" => v6::Code::IndexCreationFailed,
-            "index_already_exists" => v6::Code::IndexAlreadyExists,
-            "index_not_found" => v6::Code::IndexNotFound,
-            "invalid_index_uid" => v6::Code::InvalidIndexUid,
-            "invalid_min_word_length_for_typo" => v6::Code::InvalidSettingsTypoTolerance,
-            "invalid_state" => v6::Code::InvalidState,
-            "primary_key_inference_failed" => v6::Code::IndexPrimaryKeyNoCandidateFound,
-            "index_primary_key_already_exists" => v6::Code::IndexPrimaryKeyAlreadyExists,
-            "max_fields_limit_exceeded" => v6::Code::MaxFieldsLimitExceeded,
-            "missing_document_id" => v6::Code::MissingDocumentId,
-            "invalid_document_id" => v6::Code::InvalidDocumentId,
-            "invalid_filter" => v6::Code::InvalidSettingsFilterableAttributes,
-            "invalid_sort" => v6::Code::InvalidSettingsSortableAttributes,
-            "bad_parameter" => v6::Code::BadParameter,
-            "bad_request" => v6::Code::BadRequest,
-            "database_size_limit_reached" => v6::Code::DatabaseSizeLimitReached,
-            "document_not_found" => v6::Code::DocumentNotFound,
-            "internal" => v6::Code::Internal,
-            "invalid_geo_field" => v6::Code::InvalidDocumentGeoField,
-            "invalid_ranking_rule" => v6::Code::InvalidSettingsRankingRules,
-            "invalid_store_file" => v6::Code::InvalidStoreFile,
-            "invalid_api_key" => v6::Code::InvalidApiKey,
-            "missing_authorization_header" => v6::Code::MissingAuthorizationHeader,
-            "no_space_left_on_device" => v6::Code::NoSpaceLeftOnDevice,
-            "dump_not_found" => v6::Code::DumpNotFound,
-            "task_not_found" => v6::Code::TaskNotFound,
-            "payload_too_large" => v6::Code::PayloadTooLarge,
-            "unretrievable_document" => v6::Code::UnretrievableDocument,
-            "unsupported_media_type" => v6::Code::UnsupportedMediaType,
-            "dump_already_processing" => v6::Code::DumpAlreadyProcessing,
-            "dump_process_failed" => v6::Code::DumpProcessFailed,
-            "invalid_content_type" => v6::Code::InvalidContentType,
-            "missing_content_type" => v6::Code::MissingContentType,
-            "malformed_payload" => v6::Code::MalformedPayload,
-            "missing_payload" => v6::Code::MissingPayload,
-            "api_key_not_found" => v6::Code::ApiKeyNotFound,
-            "missing_parameter" => v6::Code::BadRequest,
-            "invalid_api_key_actions" => v6::Code::InvalidApiKeyActions,
-            "invalid_api_key_indexes" => v6::Code::InvalidApiKeyIndexes,
-            "invalid_api_key_expires_at" => v6::Code::InvalidApiKeyExpiresAt,
-            "invalid_api_key_description" => v6::Code::InvalidApiKeyDescription,
-            "invalid_api_key_name" => v6::Code::InvalidApiKeyName,
-            "invalid_api_key_uid" => v6::Code::InvalidApiKeyUid,
-            "immutable_field" => v6::Code::BadRequest,
-            "api_key_already_exists" => v6::Code::ApiKeyAlreadyExists,
-            other => {
-                log::warn!("Unknown error code {}", other);
-                v6::Code::UnretrievableErrorCode
-            }
-        };
-        v6::ResponseError::from_msg(error.message, code)
-    }
-}
-
-impl<T> From<v5::Settings<T>> for v6::Settings<v6::Unchecked> {
-    fn from(settings: v5::Settings<T>) -> Self {
-        v6::Settings {
-            displayed_attributes: settings.displayed_attributes.into(),
-            searchable_attributes: settings.searchable_attributes.into(),
-            filterable_attributes: settings.filterable_attributes.into(),
-            sortable_attributes: settings.sortable_attributes.into(),
-            ranking_rules: {
-                match settings.ranking_rules {
-                    v5::settings::Setting::Set(ranking_rules) => {
-                        let mut new_ranking_rules = vec![];
-                        for rule in ranking_rules {
-                            match v6::RankingRuleView::from_str(&rule) {
-                                Ok(new_rule) => {
-                                    new_ranking_rules.push(new_rule);
-                                }
-                                Err(_) => {
-                                    log::warn!("Error while importing settings. The ranking rule `{rule}` does not exist anymore.")
-                                }
-                            }
-                        }
-                        v6::Setting::Set(new_ranking_rules)
-                    }
-                    v5::settings::Setting::Reset => v6::Setting::Reset,
-                    v5::settings::Setting::NotSet => v6::Setting::NotSet,
-                }
-            },
-            stop_words: settings.stop_words.into(),
-            synonyms: settings.synonyms.into(),
-            distinct_attribute: settings.distinct_attribute.into(),
-            typo_tolerance: match settings.typo_tolerance {
-                v5::Setting::Set(typo) => v6::Setting::Set(v6::TypoTolerance {
-                    enabled: typo.enabled.into(),
-                    min_word_size_for_typos: match typo.min_word_size_for_typos {
-                        v5::Setting::Set(t) => v6::Setting::Set(v6::MinWordSizeForTypos {
-                            one_typo: t.one_typo.into(),
-                            two_typos: t.two_typos.into(),
-                        }),
-                        v5::Setting::Reset => v6::Setting::Reset,
-                        v5::Setting::NotSet => v6::Setting::NotSet,
-                    },
-                    disable_on_words: typo.disable_on_words.into(),
-                    disable_on_attributes: typo.disable_on_attributes.into(),
-                }),
-                v5::Setting::Reset => v6::Setting::Reset,
-                v5::Setting::NotSet => v6::Setting::NotSet,
-            },
-            faceting: match settings.faceting {
-                v5::Setting::Set(faceting) => v6::Setting::Set(v6::FacetingSettings {
-                    max_values_per_facet: faceting.max_values_per_facet.into(),
-                }),
-                v5::Setting::Reset => v6::Setting::Reset,
-                v5::Setting::NotSet => v6::Setting::NotSet,
-            },
-            pagination: match settings.pagination {
-                v5::Setting::Set(pagination) => v6::Setting::Set(v6::PaginationSettings {
-                    max_total_hits: pagination.max_total_hits.into(),
-                }),
-                v5::Setting::Reset => v6::Setting::Reset,
-                v5::Setting::NotSet => v6::Setting::NotSet,
-            },
-            _kind: std::marker::PhantomData,
-        }
-    }
-}
-
-impl From<v5::Action> for v6::Action {
-    fn from(key: v5::Action) -> Self {
-        match key {
-            v5::Action::All => v6::Action::All,
-            v5::Action::Search => v6::Action::Search,
-            v5::Action::DocumentsAll => v6::Action::DocumentsAll,
-            v5::Action::DocumentsAdd => v6::Action::DocumentsAdd,
-            v5::Action::DocumentsGet => v6::Action::DocumentsGet,
-            v5::Action::DocumentsDelete => v6::Action::DocumentsDelete,
-            v5::Action::IndexesAll => v6::Action::IndexesAll,
-            v5::Action::IndexesAdd => v6::Action::IndexesAdd,
-            v5::Action::IndexesGet => v6::Action::IndexesGet,
-            v5::Action::IndexesUpdate => v6::Action::IndexesUpdate,
-            v5::Action::IndexesDelete => v6::Action::IndexesDelete,
-            v5::Action::TasksAll => v6::Action::TasksAll,
-            v5::Action::TasksGet => v6::Action::TasksGet,
-            v5::Action::SettingsAll => v6::Action::SettingsAll,
-            v5::Action::SettingsGet => v6::Action::SettingsGet,
-            v5::Action::SettingsUpdate => v6::Action::SettingsUpdate,
-            v5::Action::StatsAll => v6::Action::StatsAll,
-            v5::Action::StatsGet => v6::Action::StatsGet,
-            v5::Action::MetricsAll => v6::Action::MetricsAll,
-            v5::Action::MetricsGet => v6::Action::MetricsGet,
-            v5::Action::DumpsAll => v6::Action::DumpsAll,
-            v5::Action::DumpsCreate => v6::Action::DumpsCreate,
-            v5::Action::Version => v6::Action::Version,
-            v5::Action::KeysAdd => v6::Action::KeysAdd,
-            v5::Action::KeysGet => v6::Action::KeysGet,
-            v5::Action::KeysUpdate => v6::Action::KeysUpdate,
-            v5::Action::KeysDelete => v6::Action::KeysDelete,
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn compat_v5_v6() {
-        let dump = File::open("tests/assets/v5.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = v5::V5Reader::open(dir).unwrap().to_v6();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"41f91d3a94911b2735ec41b07540df5c");
-        assert_eq!(update_files.len(), 22);
-        assert!(update_files[0].is_none()); // the dump creation
-        assert!(update_files[1].is_some()); // the enqueued document addition
-        assert!(update_files[2..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys), @"c9d2b467fe2fca0b35580d8a999808fb");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 200);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"e962baafd2fbae4cdd14e876053b0c5a");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-}

dump/src/reader/mod.rs

@@ -1,685 +0,0 @@
-use std::fs::File;
-use std::io::{BufReader, Read};
-
-use flate2::bufread::GzDecoder;
-use serde::Deserialize;
-use tempfile::TempDir;
-
-use self::compat::v4_to_v5::CompatV4ToV5;
-use self::compat::v5_to_v6::{CompatIndexV5ToV6, CompatV5ToV6};
-use self::v5::V5Reader;
-use self::v6::{V6IndexReader, V6Reader};
-use crate::{Result, Version};
-
-mod compat;
-
-pub(self) mod v1;
-pub(self) mod v2;
-pub(self) mod v3;
-pub(self) mod v4;
-pub(self) mod v5;
-pub(self) mod v6;
-
-pub type Document = serde_json::Map<String, serde_json::Value>;
-pub type UpdateFile = dyn Iterator<Item = Result<Document>>;
-
-pub enum DumpReader {
-    Current(V6Reader),
-    Compat(CompatV5ToV6),
-}
-
-impl DumpReader {
-    pub fn open(dump: impl Read) -> Result<DumpReader> {
-        let path = TempDir::new()?;
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(path.path())?;
-
-        #[derive(Deserialize)]
-        #[serde(rename_all = "camelCase")]
-        struct MetadataVersion {
-            pub dump_version: Version,
-        }
-        let mut meta_file = File::open(path.path().join("metadata.json"))?;
-        let MetadataVersion { dump_version } = serde_json::from_reader(&mut meta_file)?;
-
-        match dump_version {
-            Version::V1 => {
-                Ok(v1::V1Reader::open(path)?.to_v2().to_v3().to_v4().to_v5().to_v6().into())
-            }
-            Version::V2 => Ok(v2::V2Reader::open(path)?.to_v3().to_v4().to_v5().to_v6().into()),
-            Version::V3 => Ok(v3::V3Reader::open(path)?.to_v4().to_v5().to_v6().into()),
-            Version::V4 => Ok(v4::V4Reader::open(path)?.to_v5().to_v6().into()),
-            Version::V5 => Ok(v5::V5Reader::open(path)?.to_v6().into()),
-            Version::V6 => Ok(v6::V6Reader::open(path)?.into()),
-        }
-    }
-
-    pub fn version(&self) -> crate::Version {
-        match self {
-            DumpReader::Current(current) => current.version(),
-            DumpReader::Compat(compat) => compat.version(),
-        }
-    }
-
-    pub fn date(&self) -> Option<time::OffsetDateTime> {
-        match self {
-            DumpReader::Current(current) => current.date(),
-            DumpReader::Compat(compat) => compat.date(),
-        }
-    }
-
-    pub fn instance_uid(&self) -> Result<Option<uuid::Uuid>> {
-        match self {
-            DumpReader::Current(current) => current.instance_uid(),
-            DumpReader::Compat(compat) => compat.instance_uid(),
-        }
-    }
-
-    pub fn indexes(&self) -> Result<Box<dyn Iterator<Item = Result<DumpIndexReader>> + '_>> {
-        match self {
-            DumpReader::Current(current) => {
-                let indexes = Box::new(current.indexes()?.map(|res| res.map(DumpIndexReader::from)))
-                    as Box<dyn Iterator<Item = Result<DumpIndexReader>> + '_>;
-                Ok(indexes)
-            }
-            DumpReader::Compat(compat) => {
-                let indexes = Box::new(compat.indexes()?.map(|res| res.map(DumpIndexReader::from)))
-                    as Box<dyn Iterator<Item = Result<DumpIndexReader>> + '_>;
-                Ok(indexes)
-            }
-        }
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Result<Box<dyn Iterator<Item = Result<(v6::Task, Option<Box<UpdateFile>>)>> + '_>> {
-        match self {
-            DumpReader::Current(current) => Ok(current.tasks()),
-            DumpReader::Compat(compat) => compat.tasks(),
-        }
-    }
-
-    pub fn keys(&mut self) -> Result<Box<dyn Iterator<Item = Result<v6::Key>> + '_>> {
-        match self {
-            DumpReader::Current(current) => Ok(current.keys()),
-            DumpReader::Compat(compat) => compat.keys(),
-        }
-    }
-}
-
-impl From<V6Reader> for DumpReader {
-    fn from(value: V6Reader) -> Self {
-        DumpReader::Current(value)
-    }
-}
-
-impl From<CompatV5ToV6> for DumpReader {
-    fn from(value: CompatV5ToV6) -> Self {
-        DumpReader::Compat(value)
-    }
-}
-
-impl From<V5Reader> for DumpReader {
-    fn from(value: V5Reader) -> Self {
-        DumpReader::Compat(value.to_v6())
-    }
-}
-
-impl From<CompatV4ToV5> for DumpReader {
-    fn from(value: CompatV4ToV5) -> Self {
-        DumpReader::Compat(value.to_v6())
-    }
-}
-
-pub enum DumpIndexReader {
-    Current(v6::V6IndexReader),
-    Compat(Box<CompatIndexV5ToV6>),
-}
-
-impl DumpIndexReader {
-    pub fn new_v6(v6: v6::V6IndexReader) -> DumpIndexReader {
-        DumpIndexReader::Current(v6)
-    }
-
-    pub fn metadata(&self) -> &crate::IndexMetadata {
-        match self {
-            DumpIndexReader::Current(v6) => v6.metadata(),
-            DumpIndexReader::Compat(compat) => compat.metadata(),
-        }
-    }
-
-    pub fn documents(&mut self) -> Result<Box<dyn Iterator<Item = Result<Document>> + '_>> {
-        match self {
-            DumpIndexReader::Current(v6) => v6
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-            DumpIndexReader::Compat(compat) => compat
-                .documents()
-                .map(|iter| Box::new(iter) as Box<dyn Iterator<Item = Result<Document>> + '_>),
-        }
-    }
-
-    pub fn settings(&mut self) -> Result<v6::Settings<v6::Checked>> {
-        match self {
-            DumpIndexReader::Current(v6) => v6.settings(),
-            DumpIndexReader::Compat(compat) => compat.settings(),
-        }
-    }
-}
-
-impl From<V6IndexReader> for DumpIndexReader {
-    fn from(value: V6IndexReader) -> Self {
-        DumpIndexReader::Current(value)
-    }
-}
-
-impl From<CompatIndexV5ToV6> for DumpIndexReader {
-    fn from(value: CompatIndexV5ToV6) -> Self {
-        DumpIndexReader::Compat(Box::new(value))
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-
-    use meili_snap::insta;
-
-    use super::*;
-
-    #[test]
-    fn import_dump_v5() {
-        let dump = File::open("tests/assets/v5.dump").unwrap();
-        let mut dump = DumpReader::open(dump).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"41f91d3a94911b2735ec41b07540df5c");
-        assert_eq!(update_files.len(), 22);
-        assert!(update_files[0].is_none()); // the dump creation
-        assert!(update_files[1].is_some()); // the enqueued document addition
-        assert!(update_files[2..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys), @"c9d2b467fe2fca0b35580d8a999808fb");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "2022-10-04T15:51:35.939396731Z",
-          "updatedAt": "2022-10-04T15:55:01.897325373Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "2022-10-04T15:51:35.291992167Z",
-          "updatedAt": "2022-10-04T15:55:10.33561842Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 200);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"e962baafd2fbae4cdd14e876053b0c5a");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "2022-10-04T15:51:37.381094632Z",
-          "updatedAt": "2022-10-04T15:55:02.394503431Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-
-    #[test]
-    fn import_dump_v4() {
-        let dump = File::open("tests/assets/v4.dump").unwrap();
-        let mut dump = DumpReader::open(dump).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"c2445ddd1785528b80f2ba534d3bd00c");
-        assert_eq!(update_files.len(), 10);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys, { "[].uid" => "[uuid]" }), @"d751713988987e9331980363e24189ce");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "2022-10-06T12:53:39.360187055Z",
-          "updatedAt": "2022-10-06T12:53:40.603035979Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "2022-10-06T12:53:38.710611568Z",
-          "updatedAt": "2022-10-06T12:53:49.785862546Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"786022a66ecb992c8a2a60fee070a5ab");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "2022-10-06T12:53:40.831649057Z",
-          "updatedAt": "2022-10-06T12:53:41.116036186Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-
-    #[test]
-    fn import_dump_v3() {
-        let dump = File::open("tests/assets/v3.dump").unwrap();
-        let mut dump = DumpReader::open(dump).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
-        assert_eq!(dump.instance_uid().unwrap(), None);
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"cd12efd308fe3ed226356a727ab42ed3");
-        assert_eq!(update_files.len(), 10);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys), @"d751713988987e9331980363e24189ce");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies2 = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d153b5a81d8b3cdcbe1dec270b574022");
-
-        // movies2
-        insta::assert_json_snapshot!(movies2.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies_2",
-          "primaryKey": null,
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies2.settings().unwrap());
-        let documents = movies2.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 0);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d751713988987e9331980363e24189ce");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-
-    #[test]
-    fn import_dump_v2() {
-        let dump = File::open("tests/assets/v2.dump").unwrap();
-        let mut dump = DumpReader::open(dump).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
-        assert_eq!(dump.instance_uid().unwrap(), None);
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"bc616290adfe7d09a624cf6065ca9069");
-        assert_eq!(update_files.len(), 9);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys), @"d751713988987e9331980363e24189ce");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies2 = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d153b5a81d8b3cdcbe1dec270b574022");
-
-        // movies2
-        insta::assert_json_snapshot!(movies2.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies_2",
-          "primaryKey": null,
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies2.settings().unwrap());
-        let documents = movies2.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 0);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d751713988987e9331980363e24189ce");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-
-    #[test]
-    fn import_dump_v2_from_meilisearch_v0_22_0_issue_3435() {
-        let dump = File::open("tests/assets/v2-v0.22.0.dump").unwrap();
-        let mut dump = DumpReader::open(dump).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2023-01-30 16:26:09.247261 +00:00:00");
-        assert_eq!(dump.instance_uid().unwrap(), None);
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"2db37756d8af1fb7623436b76e8956a6");
-        assert_eq!(update_files.len(), 8);
-        assert!(update_files[0..].iter().all(|u| u.is_none())); // everything already processed
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys), @"d751713988987e9331980363e24189ce");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"0227598af846e574139ee0b80e03a720");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-
-    #[test]
-    fn import_dump_v1() {
-        let dump = File::open("tests/assets/v1.dump").unwrap();
-        let mut dump = DumpReader::open(dump).unwrap();
-
-        // top level infos
-        assert_eq!(dump.date(), None);
-        assert_eq!(dump.instance_uid().unwrap(), None);
-
-        // tasks
-        let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"8df6eab075a44b3c1af6b726f9fd9a43");
-        assert_eq!(update_files.len(), 9);
-        assert!(update_files[..].iter().all(|u| u.is_none())); // no update file in dump v1
-
-        // keys
-        let keys = dump.keys().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot!(meili_snap::json_string!(keys), @"[]");
-        meili_snap::snapshot_hash!(meili_snap::json_string!(keys), @"d751713988987e9331980363e24189ce");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "2022-10-02T13:23:39.976870431Z",
-          "updatedAt": "2022-10-02T13:27:54.353262482Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "2022-10-02T13:15:29.477512777Z",
-          "updatedAt": "2022-10-02T13:21:12.671204856Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b63dbed5bbc059f3e32bc471ae699bf5");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "2022-10-02T13:38:26.358882984Z",
-          "updatedAt": "2022-10-02T13:38:26.385609433Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"aa24c0cfc733d66c396237ad44263bed");
-    }
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v1-11.snap

@@ -1,24 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v1-5.snap

@@ -1,38 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v1-8.snap

@@ -1,31 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "genres",
-    "id"
-  ],
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2-11.snap

@@ -1,23 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies2.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2-14.snap

@@ -1,23 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2-5.snap

@@ -1,37 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2-8.snap

@@ -1,24 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2_from_meilisearch_v0_22_0_issue_3435-11.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2_from_meilisearch_v0_22_0_issue_3435-5.snap

@@ -1,39 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v2_from_meilisearch_v0_22_0_issue_3435-8.snap

@@ -1,30 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v3-11.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies2.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v3-14.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v3-5.snap

@@ -1,39 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v3-8.snap

@@ -1,31 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v4-12.snap

@@ -1,34 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  }
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v4-6.snap

@@ -1,48 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  }
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v4-9.snap

@@ -1,40 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  }
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v5-12.snap

@@ -1,40 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  },
-  "faceting": {
-    "maxValuesPerFacet": 100
-  },
-  "pagination": {
-    "maxTotalHits": 1000
-  }
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v5-6.snap

@@ -1,54 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  },
-  "faceting": {
-    "maxValuesPerFacet": 100
-  },
-  "pagination": {
-    "maxTotalHits": 1000
-  }
-}

dump/src/reader/snapshots/dump__reader__test__import_dump_v5-9.snap

@@ -1,46 +0,0 @@
----
-source: dump/src/reader/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null,
-  "typoTolerance": {
-    "enabled": true,
-    "minWordSizeForTypos": {
-      "oneTypo": 5,
-      "twoTypos": 9
-    },
-    "disableOnWords": [],
-    "disableOnAttributes": []
-  },
-  "faceting": {
-    "maxValuesPerFacet": 100
-  },
-  "pagination": {
-    "maxTotalHits": 1000
-  }
-}

dump/src/reader/v1/mod.rs

@@ -1,262 +0,0 @@
-use std::fs::{self, File};
-use std::io::{BufRead, BufReader};
-use std::path::{Path, PathBuf};
-
-use serde::Deserialize;
-use tempfile::TempDir;
-use time::OffsetDateTime;
-
-use super::compat::v1_to_v2::CompatV1ToV2;
-use super::Document;
-use crate::{IndexMetadata, Result, Version};
-
-pub mod settings;
-pub mod update;
-
-pub struct V1Reader {
-    pub dump: TempDir,
-    pub db_version: String,
-    pub dump_version: crate::Version,
-    indexes: Vec<V1Index>,
-}
-
-pub struct IndexUuid {
-    pub name: String,
-    pub uid: String,
-}
-pub type Task = self::update::UpdateStatus;
-
-struct V1Index {
-    metadata: IndexMetadataV1,
-    path: PathBuf,
-}
-
-impl V1Index {
-    pub fn new(path: PathBuf, metadata: Index) -> Self {
-        Self { metadata: metadata.into(), path }
-    }
-
-    pub fn open(&self) -> Result<V1IndexReader> {
-        V1IndexReader::new(&self.path, self.metadata.clone())
-    }
-
-    pub fn metadata(&self) -> &IndexMetadata {
-        &self.metadata.metadata
-    }
-}
-
-pub struct V1IndexReader {
-    metadata: IndexMetadataV1,
-    documents: BufReader<File>,
-    settings: BufReader<File>,
-    updates: BufReader<File>,
-}
-
-impl V1IndexReader {
-    pub fn new(path: &Path, metadata: IndexMetadataV1) -> Result<Self> {
-        Ok(V1IndexReader {
-            metadata,
-            documents: BufReader::new(File::open(path.join("documents.jsonl"))?),
-            settings: BufReader::new(File::open(path.join("settings.json"))?),
-            updates: BufReader::new(File::open(path.join("updates.jsonl"))?),
-        })
-    }
-
-    pub fn metadata(&self) -> &IndexMetadata {
-        &self.metadata.metadata
-    }
-
-    pub fn documents(&mut self) -> Result<impl Iterator<Item = Result<Document>> + '_> {
-        Ok((&mut self.documents)
-            .lines()
-            .map(|line| -> Result<_> { Ok(serde_json::from_str(&line?)?) }))
-    }
-
-    pub fn settings(&mut self) -> Result<self::settings::Settings> {
-        Ok(serde_json::from_reader(&mut self.settings)?)
-    }
-
-    pub fn tasks(self) -> impl Iterator<Item = Result<Task>> {
-        self.updates.lines().map(|line| -> Result<_> { Ok(serde_json::from_str(&line?)?) })
-    }
-}
-
-impl V1Reader {
-    pub fn open(dump: TempDir) -> Result<Self> {
-        let meta_file = fs::read(dump.path().join("metadata.json"))?;
-        let metadata: Metadata = serde_json::from_reader(&*meta_file)?;
-
-        let mut indexes = Vec::new();
-
-        for index in metadata.indexes.into_iter() {
-            let index_path = dump.path().join(&index.uid);
-            indexes.push(V1Index::new(index_path, index));
-        }
-
-        Ok(V1Reader {
-            dump,
-            indexes,
-            db_version: metadata.db_version,
-            dump_version: metadata.dump_version,
-        })
-    }
-
-    pub fn to_v2(self) -> CompatV1ToV2 {
-        CompatV1ToV2 { from: self }
-    }
-
-    pub fn index_uuid(&self) -> Vec<IndexUuid> {
-        self.indexes
-            .iter()
-            .map(|index| IndexUuid {
-                name: index.metadata.name.to_owned(),
-                uid: index.metadata().uid.to_owned(),
-            })
-            .collect()
-    }
-
-    pub fn version(&self) -> Version {
-        Version::V1
-    }
-
-    pub fn date(&self) -> Option<OffsetDateTime> {
-        None
-    }
-
-    pub fn indexes(&self) -> Result<impl Iterator<Item = Result<V1IndexReader>> + '_> {
-        Ok(self.indexes.iter().map(|index| index.open()))
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Index {
-    pub name: String,
-    pub uid: String,
-    #[serde(with = "time::serde::rfc3339")]
-    created_at: OffsetDateTime,
-    #[serde(with = "time::serde::rfc3339")]
-    updated_at: OffsetDateTime,
-    pub primary_key: Option<String>,
-}
-
-#[derive(Clone)]
-pub struct IndexMetadataV1 {
-    pub name: String,
-    pub metadata: crate::IndexMetadata,
-}
-
-impl From<Index> for IndexMetadataV1 {
-    fn from(index: Index) -> Self {
-        IndexMetadataV1 {
-            name: index.name,
-            metadata: crate::IndexMetadata {
-                uid: index.uid,
-                primary_key: index.primary_key,
-                created_at: index.created_at,
-                updated_at: index.updated_at,
-            },
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Metadata {
-    pub indexes: Vec<Index>,
-    pub db_version: String,
-    pub dump_version: crate::Version,
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn read_dump_v1() {
-        let dump = File::open("tests/assets/v1.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let dump = V1Reader::open(dir).unwrap();
-
-        // top level infos
-        assert_eq!(dump.date(), None);
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut dnd_spells = indexes.pop().unwrap();
-
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "2022-10-02T13:23:39.976870431Z",
-          "updatedAt": "2022-10-02T13:27:54.353262482Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b01c8371aea4c7171af0d4d846a2bdca");
-
-        // products tasks
-        let tasks = products.tasks().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"91de507f206ad21964584021932ba7a7");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "2022-10-02T13:15:29.477512777Z",
-          "updatedAt": "2022-10-02T13:21:12.671204856Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"b63dbed5bbc059f3e32bc471ae699bf5");
-
-        // movies tasks
-        let tasks = movies.tasks().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"55eef4de2bef7e84c5ce0bee47488f56");
-
-        // spells
-        insta::assert_json_snapshot!(dnd_spells.metadata(), @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "2022-10-02T13:38:26.358882984Z",
-          "updatedAt": "2022-10-02T13:38:26.385609433Z"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(dnd_spells.settings().unwrap());
-        let documents = dnd_spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"aa24c0cfc733d66c396237ad44263bed");
-
-        // spells tasks
-        let tasks = dnd_spells.tasks().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"836dd7d64d5ad20ad901c44b1b161a4c");
-    }
-}

dump/src/reader/v1/settings.rs

@@ -1,94 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-use std::result::Result as StdResult;
-use std::str::FromStr;
-
-use once_cell::sync::Lazy;
-use regex::Regex;
-use serde::{Deserialize, Deserializer, Serialize};
-
-#[derive(Default, Clone, Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct Settings {
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub ranking_rules: Option<Option<Vec<String>>>,
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub distinct_attribute: Option<Option<String>>,
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub searchable_attributes: Option<Option<Vec<String>>>,
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub displayed_attributes: Option<Option<BTreeSet<String>>>,
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub stop_words: Option<Option<BTreeSet<String>>>,
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub synonyms: Option<Option<BTreeMap<String, Vec<String>>>>,
-    #[serde(default, deserialize_with = "deserialize_some")]
-    pub attributes_for_faceting: Option<Option<Vec<String>>>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SettingsUpdate {
-    pub ranking_rules: UpdateState<Vec<RankingRule>>,
-    pub distinct_attribute: UpdateState<String>,
-    pub primary_key: UpdateState<String>,
-    pub searchable_attributes: UpdateState<Vec<String>>,
-    pub displayed_attributes: UpdateState<BTreeSet<String>>,
-    pub stop_words: UpdateState<BTreeSet<String>>,
-    pub synonyms: UpdateState<BTreeMap<String, Vec<String>>>,
-    pub attributes_for_faceting: UpdateState<Vec<String>>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum UpdateState<T> {
-    Update(T),
-    Clear,
-    Nothing,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum RankingRule {
-    Typo,
-    Words,
-    Proximity,
-    Attribute,
-    WordsPosition,
-    Exactness,
-    Asc(String),
-    Desc(String),
-}
-
-static ASC_DESC_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r#"(asc|desc)\(([\w_-]+)\)"#).unwrap());
-
-impl FromStr for RankingRule {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "typo" => Self::Typo,
-            "words" => Self::Words,
-            "proximity" => Self::Proximity,
-            "attribute" => Self::Attribute,
-            "wordsPosition" => Self::WordsPosition,
-            "exactness" => Self::Exactness,
-            text => {
-                let caps = ASC_DESC_REGEX.captures(text).ok_or(())?;
-                let order = caps.get(1).unwrap().as_str();
-                let field_name = caps.get(2).unwrap().as_str();
-                match order {
-                    "asc" => Self::Asc(field_name.to_string()),
-                    "desc" => Self::Desc(field_name.to_string()),
-                    _ => return Err(()),
-                }
-            }
-        })
-    }
-}
-
-// Any value that is present is considered Some value, including null.
-fn deserialize_some<'de, T, D>(deserializer: D) -> StdResult<Option<T>, D::Error>
-where
-    T: Deserialize<'de>,
-    D: Deserializer<'de>,
-{
-    Deserialize::deserialize(deserializer).map(Some)
-}

dump/src/reader/v1/snapshots/dump__reader__v1__test__read_dump_v1-10.snap

@@ -1,24 +0,0 @@
----
-source: dump/src/reader/v1/mod.rs
-expression: dnd_spells.settings().unwrap()
----
-{
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "wordsPosition",
-    "exactness"
-  ],
-  "distinctAttribute": null,
-  "searchableAttributes": [
-    "*"
-  ],
-  "displayedAttributes": [
-    "*"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "attributesForFaceting": []
-}

dump/src/reader/v1/snapshots/dump__reader__v1__test__read_dump_v1-2.snap

@@ -1,38 +0,0 @@
----
-source: dump/src/reader/v1/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "wordsPosition",
-    "exactness"
-  ],
-  "distinctAttribute": null,
-  "searchableAttributes": [
-    "*"
-  ],
-  "displayedAttributes": [
-    "*"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "attributesForFaceting": []
-}

dump/src/reader/v1/snapshots/dump__reader__v1__test__read_dump_v1-6.snap

@@ -1,28 +0,0 @@
----
-source: dump/src/reader/v1/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "rankingRules": [
-    "typo",
-    "words",
-    "proximity",
-    "attribute",
-    "wordsPosition",
-    "exactness",
-    "asc(release_date)"
-  ],
-  "distinctAttribute": null,
-  "searchableAttributes": [
-    "*"
-  ],
-  "displayedAttributes": [
-    "*"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "attributesForFaceting": [
-    "id",
-    "genres"
-  ]
-}

dump/src/reader/v1/update.rs

@@ -1,74 +0,0 @@
-use serde::{Deserialize, Serialize};
-use time::OffsetDateTime;
-
-use super::settings::SettingsUpdate;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "name")]
-pub enum UpdateType {
-    ClearAll,
-    Customs,
-    DocumentsAddition { number: usize },
-    DocumentsPartial { number: usize },
-    DocumentsDeletion { number: usize },
-    Settings { settings: Box<SettingsUpdate> },
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ProcessedUpdateResult {
-    pub update_id: u64,
-    #[serde(rename = "type")]
-    pub update_type: UpdateType,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error_type: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error_code: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error_link: Option<String>,
-    pub duration: f64, // in seconds
-    #[serde(with = "time::serde::rfc3339")]
-    pub enqueued_at: OffsetDateTime,
-    #[serde(with = "time::serde::rfc3339")]
-    pub processed_at: OffsetDateTime,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct EnqueuedUpdateResult {
-    pub update_id: u64,
-    #[serde(rename = "type")]
-    pub update_type: UpdateType,
-    #[serde(with = "time::serde::rfc3339")]
-    pub enqueued_at: OffsetDateTime,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", tag = "status")]
-pub enum UpdateStatus {
-    Enqueued {
-        #[serde(flatten)]
-        content: EnqueuedUpdateResult,
-    },
-    Failed {
-        #[serde(flatten)]
-        content: ProcessedUpdateResult,
-    },
-    Processed {
-        #[serde(flatten)]
-        content: ProcessedUpdateResult,
-    },
-}
-
-impl UpdateStatus {
-    pub fn enqueued_at(&self) -> &OffsetDateTime {
-        match self {
-            UpdateStatus::Enqueued { content } => &content.enqueued_at,
-            UpdateStatus::Failed { content } | UpdateStatus::Processed { content } => {
-                &content.enqueued_at
-            }
-        }
-    }
-}

dump/src/reader/v2/errors.rs

@@ -1,14 +0,0 @@
-use http::StatusCode;
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct ResponseError {
-    #[serde(skip)]
-    pub code: StatusCode,
-    pub message: String,
-    pub error_code: String,
-    pub error_type: String,
-    pub error_link: String,
-}

dump/src/reader/v2/meta.rs

@@ -1,18 +0,0 @@
-use serde::Deserialize;
-use uuid::Uuid;
-
-use super::Settings;
-
-#[derive(Deserialize, Debug, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct IndexUuid {
-    pub uid: String,
-    pub uuid: Uuid,
-}
-
-#[derive(Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct DumpMeta {
-    pub settings: Settings<super::Unchecked>,
-    pub primary_key: Option<String>,
-}

dump/src/reader/v2/mod.rs

@@ -1,387 +0,0 @@
-//! ```text
-//! .
-//! ├── indexes
-//! │   ├── index-40d14c5f-37ae-4873-9d51-b69e014a0d30
-//! │   │   ├── documents.jsonl
-//! │   │   └── meta.json
-//! │   ├── index-88202369-4524-4410-9b3d-3e924c867fec
-//! │   │   ├── documents.jsonl
-//! │   │   └── meta.json
-//! │   ├── index-b7f2d03b-bf9b-40d9-a25b-94dc5ec60c32
-//! │   │   ├── documents.jsonl
-//! │   │   └── meta.json
-//! │   └── index-dc9070b3-572d-4f30-ab45-d4903ab71708
-//! │       ├── documents.jsonl
-//! │       └── meta.json
-//! ├── index_uuids
-//! │   └── data.jsonl
-//! ├── metadata.json
-//! └── updates
-//!     ├── data.jsonl
-//!     └── update_files
-//!         └── update_202573df-718b-4d80-9a65-2ee397c23dc3
-//! ```
-
-use std::fs::{self, File};
-use std::io::{BufRead, BufReader};
-use std::path::Path;
-
-use serde::{Deserialize, Serialize};
-use tempfile::TempDir;
-use time::OffsetDateTime;
-
-pub mod errors;
-pub mod meta;
-pub mod settings;
-pub mod updates;
-
-use self::meta::{DumpMeta, IndexUuid};
-use super::compat::v2_to_v3::CompatV2ToV3;
-use super::Document;
-use crate::{IndexMetadata, Result, Version};
-
-pub type Settings<T> = settings::Settings<T>;
-pub type Setting<T> = settings::Setting<T>;
-pub type Checked = settings::Checked;
-pub type Unchecked = settings::Unchecked;
-
-pub type Task = updates::UpdateEntry;
-
-// everything related to the errors
-pub type ResponseError = errors::ResponseError;
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Metadata {
-    db_version: String,
-    index_db_size: usize,
-    update_db_size: usize,
-    #[serde(with = "time::serde::rfc3339")]
-    dump_date: OffsetDateTime,
-}
-
-pub struct V2Reader {
-    dump: TempDir,
-    metadata: Metadata,
-    tasks: BufReader<File>,
-    pub index_uuid: Vec<IndexUuid>,
-}
-
-impl V2Reader {
-    pub fn open(dump: TempDir) -> Result<Self> {
-        let meta_file = fs::read(dump.path().join("metadata.json"))?;
-        let metadata = serde_json::from_reader(&*meta_file)?;
-        let index_uuid = File::open(dump.path().join("index_uuids/data.jsonl"))?;
-        let index_uuid = BufReader::new(index_uuid);
-        let index_uuid = index_uuid
-            .lines()
-            .map(|line| -> Result<_> { Ok(serde_json::from_str(&line?)?) })
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(V2Reader {
-            metadata,
-            tasks: BufReader::new(
-                File::open(dump.path().join("updates").join("data.jsonl")).unwrap(),
-            ),
-            index_uuid,
-            dump,
-        })
-    }
-
-    pub fn to_v3(self) -> CompatV2ToV3 {
-        CompatV2ToV3::new(self)
-    }
-
-    pub fn index_uuid(&self) -> Vec<IndexUuid> {
-        self.index_uuid.clone()
-    }
-
-    pub fn version(&self) -> Version {
-        Version::V2
-    }
-
-    pub fn date(&self) -> Option<OffsetDateTime> {
-        Some(self.metadata.dump_date)
-    }
-
-    pub fn indexes(&self) -> Result<impl Iterator<Item = Result<V2IndexReader>> + '_> {
-        Ok(self.index_uuid.iter().map(|index| -> Result<_> {
-            V2IndexReader::new(
-                index.uid.clone(),
-                &self.dump.path().join("indexes").join(format!("index-{}", index.uuid)),
-            )
-        }))
-    }
-
-    pub fn tasks(&mut self) -> Box<dyn Iterator<Item = Result<(Task, Option<UpdateFile>)>> + '_> {
-        Box::new((&mut self.tasks).lines().map(|line| -> Result<_> {
-            let task: Task = serde_json::from_str(&line?)?;
-            if !task.is_finished() {
-                if let Some(uuid) = task.get_content_uuid() {
-                    let update_file_path = self
-                        .dump
-                        .path()
-                        .join("updates")
-                        .join("update_files")
-                        .join(format!("update_{}", uuid));
-                    Ok((task, Some(UpdateFile::new(&update_file_path)?)))
-                } else {
-                    Ok((task, None))
-                }
-            } else {
-                Ok((task, None))
-            }
-        }))
-    }
-}
-
-pub struct V2IndexReader {
-    metadata: IndexMetadata,
-    settings: Settings<Checked>,
-
-    documents: BufReader<File>,
-}
-
-impl V2IndexReader {
-    pub fn new(name: String, path: &Path) -> Result<Self> {
-        let meta = File::open(path.join("meta.json"))?;
-        let meta: DumpMeta = serde_json::from_reader(meta)?;
-
-        let metadata = IndexMetadata {
-            uid: name,
-            primary_key: meta.primary_key,
-            // FIXME: Iterate over the whole task queue to find the creation and last update date.
-            created_at: OffsetDateTime::now_utc(),
-            updated_at: OffsetDateTime::now_utc(),
-        };
-
-        let ret = V2IndexReader {
-            metadata,
-            settings: meta.settings.check(),
-            documents: BufReader::new(File::open(path.join("documents.jsonl"))?),
-        };
-
-        Ok(ret)
-    }
-
-    pub fn metadata(&self) -> &IndexMetadata {
-        &self.metadata
-    }
-
-    pub fn documents(&mut self) -> Result<impl Iterator<Item = Result<Document>> + '_> {
-        Ok((&mut self.documents)
-            .lines()
-            .map(|line| -> Result<_> { Ok(serde_json::from_str(&line?)?) }))
-    }
-
-    pub fn settings(&mut self) -> Result<Settings<Checked>> {
-        Ok(self.settings.clone())
-    }
-}
-
-pub struct UpdateFile {
-    documents: Vec<Document>,
-    index: usize,
-}
-
-impl UpdateFile {
-    fn new(path: &Path) -> Result<Self> {
-        let reader = BufReader::new(File::open(path)?);
-        Ok(UpdateFile { documents: serde_json::from_reader(reader)?, index: 0 })
-    }
-}
-
-impl Iterator for UpdateFile {
-    type Item = Result<Document>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.index += 1;
-        self.documents.get(self.index - 1).cloned().map(Ok)
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn read_dump_v2() {
-        let dump = File::open("tests/assets/v2.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = V2Reader::open(dir).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, mut update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"ec5fc0a14bf735ad4e361d5aa8a89ac6");
-        assert_eq!(update_files.len(), 9);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        let update_file = update_files.remove(0).unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(update_file), @"7b8889539b669c7b9ddba448bafa385d");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies2 = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d153b5a81d8b3cdcbe1dec270b574022");
-
-        // movies2
-        insta::assert_json_snapshot!(movies2.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies_2",
-          "primaryKey": null,
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies2.settings().unwrap());
-        let documents = movies2.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 0);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d751713988987e9331980363e24189ce");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-
-    #[test]
-    fn read_dump_v2_from_meilisearch_v0_22_0_issue_3435() {
-        let dump = File::open("tests/assets/v2-v0.22.0.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = V2Reader::open(dir).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2023-01-30 16:26:09.247261 +00:00:00");
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"aca8ba13046272664eb3ea2da3031633");
-        assert_eq!(update_files.len(), 8);
-        assert!(update_files[0..].iter().all(|u| u.is_none())); // everything has already been processed
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"0227598af846e574139ee0b80e03a720");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-}

dump/src/reader/v2/settings.rs

@@ -1,269 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-use std::fmt;
-use std::marker::PhantomData;
-use std::str::FromStr;
-
-use serde::{Deserialize, Deserializer};
-
-#[cfg(test)]
-fn serialize_with_wildcard<S>(
-    field: &Setting<Vec<String>>,
-    s: S,
-) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    use serde::Serialize;
-
-    let wildcard = vec!["*".to_string()];
-    match field {
-        Setting::Set(value) => Some(value),
-        Setting::Reset => Some(&wildcard),
-        Setting::NotSet => None,
-    }
-    .serialize(s)
-}
-
-#[derive(Clone, Default, Debug)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct Checked;
-
-#[derive(Clone, Default, Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct Unchecked;
-
-#[derive(Debug, Clone, Default, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(deny_unknown_fields)]
-#[serde(rename_all = "camelCase")]
-#[serde(bound(serialize = "T: serde::Serialize", deserialize = "T: Deserialize<'static>"))]
-pub struct Settings<T> {
-    #[serde(
-        default,
-        serialize_with = "serialize_with_wildcard",
-        skip_serializing_if = "Setting::is_not_set"
-    )]
-    pub displayed_attributes: Setting<Vec<String>>,
-
-    #[serde(
-        default,
-        serialize_with = "serialize_with_wildcard",
-        skip_serializing_if = "Setting::is_not_set"
-    )]
-    pub searchable_attributes: Setting<Vec<String>>,
-
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub filterable_attributes: Setting<BTreeSet<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub sortable_attributes: Setting<BTreeSet<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub ranking_rules: Setting<Vec<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub stop_words: Setting<BTreeSet<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub synonyms: Setting<BTreeMap<String, Vec<String>>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub distinct_attribute: Setting<String>,
-
-    #[serde(skip)]
-    pub _kind: PhantomData<T>,
-}
-
-impl Settings<Unchecked> {
-    pub fn check(self) -> Settings<Checked> {
-        let displayed_attributes = match self.displayed_attributes {
-            Setting::Set(fields) => {
-                if fields.iter().any(|f| f == "*") {
-                    Setting::Reset
-                } else {
-                    Setting::Set(fields)
-                }
-            }
-            otherwise => otherwise,
-        };
-
-        let searchable_attributes = match self.searchable_attributes {
-            Setting::Set(fields) => {
-                if fields.iter().any(|f| f == "*") {
-                    Setting::Reset
-                } else {
-                    Setting::Set(fields)
-                }
-            }
-            otherwise => otherwise,
-        };
-
-        Settings {
-            displayed_attributes,
-            searchable_attributes,
-            filterable_attributes: self.filterable_attributes,
-            sortable_attributes: self.sortable_attributes,
-            ranking_rules: self.ranking_rules,
-            stop_words: self.stop_words,
-            synonyms: self.synonyms,
-            distinct_attribute: self.distinct_attribute,
-            _kind: PhantomData,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Setting<T> {
-    Set(T),
-    Reset,
-    NotSet,
-}
-
-impl<T> Default for Setting<T> {
-    fn default() -> Self {
-        Self::NotSet
-    }
-}
-
-impl<T> Setting<T> {
-    pub const fn is_not_set(&self) -> bool {
-        matches!(self, Self::NotSet)
-    }
-
-    pub fn map<A>(self, f: fn(T) -> A) -> Setting<A> {
-        match self {
-            Setting::Set(a) => Setting::Set(f(a)),
-            Setting::Reset => Setting::Reset,
-            Setting::NotSet => Setting::NotSet,
-        }
-    }
-}
-
-#[cfg(test)]
-impl<T: serde::Serialize> serde::Serialize for Setting<T> {
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self {
-            Self::Set(value) => Some(value),
-            // Usually not_set isn't serialized by setting skip_serializing_if field attribute
-            Self::NotSet | Self::Reset => None,
-        }
-        .serialize(serializer)
-    }
-}
-
-impl<'de, T: Deserialize<'de>> Deserialize<'de> for Setting<T> {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Deserialize::deserialize(deserializer).map(|x| match x {
-            Some(x) => Self::Set(x),
-            None => Self::Reset, // Reset is forced by sending null value
-        })
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Criterion {
-    /// Sorted by decreasing number of matched query terms.
-    /// Query words at the front of an attribute is considered better than if it was at the back.
-    Words,
-    /// Sorted by increasing number of typos.
-    Typo,
-    /// Sorted by increasing distance between matched query terms.
-    Proximity,
-    /// Documents with quey words contained in more important
-    /// attributes are considered better.
-    Attribute,
-    /// Dynamically sort at query time the documents. None, one or multiple Asc/Desc sortable
-    /// attributes can be used in place of this criterion at query time.
-    Sort,
-    /// Sorted by the similarity of the matched words with the query words.
-    Exactness,
-    /// Sorted by the increasing value of the field specified.
-    Asc(String),
-    /// Sorted by the decreasing value of the field specified.
-    Desc(String),
-}
-
-impl Criterion {
-    /// Returns the field name parameter of this criterion.
-    pub fn field_name(&self) -> Option<&str> {
-        match self {
-            Criterion::Asc(name) | Criterion::Desc(name) => Some(name),
-            _otherwise => None,
-        }
-    }
-}
-
-impl FromStr for Criterion {
-    // since we're not going to show the custom error message we can override the
-    // error type.
-    type Err = ();
-
-    fn from_str(text: &str) -> Result<Criterion, Self::Err> {
-        match text {
-            "words" => Ok(Criterion::Words),
-            "typo" => Ok(Criterion::Typo),
-            "proximity" => Ok(Criterion::Proximity),
-            "attribute" => Ok(Criterion::Attribute),
-            "sort" => Ok(Criterion::Sort),
-            "exactness" => Ok(Criterion::Exactness),
-            text => match AscDesc::from_str(text) {
-                Ok(AscDesc::Asc(field)) => Ok(Criterion::Asc(field)),
-                Ok(AscDesc::Desc(field)) => Ok(Criterion::Desc(field)),
-                Err(_) => Err(()),
-            },
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
-pub enum AscDesc {
-    Asc(String),
-    Desc(String),
-}
-
-impl FromStr for AscDesc {
-    type Err = ();
-
-    // since we don't know if this comes from the old or new syntax we need to check
-    // for both syntax.
-    // WARN: this code doesn't come from the original meilisearch v0.22.0 but was
-    // written specifically to be able to import the dump of meilisearch v0.21.0 AND
-    // meilisearch v0.22.0.
-    fn from_str(text: &str) -> Result<AscDesc, Self::Err> {
-        if let Some((field_name, asc_desc)) = text.rsplit_once(':') {
-            match asc_desc {
-                "asc" => Ok(AscDesc::Asc(field_name.to_string())),
-                "desc" => Ok(AscDesc::Desc(field_name.to_string())),
-                _ => Err(()),
-            }
-        } else if text.starts_with("asc(") && text.ends_with(')') {
-            Ok(AscDesc::Asc(
-                text.strip_prefix("asc(").unwrap().strip_suffix(')').unwrap().to_string(),
-            ))
-        } else if text.starts_with("desc(") && text.ends_with(')') {
-            Ok(AscDesc::Desc(
-                text.strip_prefix("desc(").unwrap().strip_suffix(')').unwrap().to_string(),
-            ))
-        } else {
-            Err(())
-        }
-    }
-}
-
-impl fmt::Display for Criterion {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use Criterion::*;
-
-        match self {
-            Words => f.write_str("words"),
-            Typo => f.write_str("typo"),
-            Proximity => f.write_str("proximity"),
-            Attribute => f.write_str("attribute"),
-            Sort => f.write_str("sort"),
-            Exactness => f.write_str("exactness"),
-            Asc(attr) => write!(f, "{}:asc", attr),
-            Desc(attr) => write!(f, "{}:desc", attr),
-        }
-    }
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2-11.snap

@@ -1,23 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: movies2.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2-14.snap

@@ -1,23 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2-5.snap

@@ -1,37 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2-8.snap

@@ -1,24 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness",
-    "asc(release_date)"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2_from_meilisearch_v0_22_0_issue_3435-10.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2_from_meilisearch_v0_22_0_issue_3435-4.snap

@@ -1,39 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/v2/snapshots/dump__reader__v2__test__read_dump_v2_from_meilisearch_v0_22_0_issue_3435-7.snap

@@ -1,30 +0,0 @@
----
-source: dump/src/reader/v2/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v2/updates.rs

@@ -1,230 +0,0 @@
-use serde::Deserialize;
-use time::OffsetDateTime;
-use uuid::Uuid;
-
-use super::{ResponseError, Settings, Unchecked};
-
-#[derive(Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct UpdateEntry {
-    pub uuid: Uuid,
-    pub update: UpdateStatus,
-}
-
-impl UpdateEntry {
-    pub fn is_finished(&self) -> bool {
-        match self.update {
-            UpdateStatus::Processing(_) | UpdateStatus::Enqueued(_) => false,
-            UpdateStatus::Processed(_) | UpdateStatus::Aborted(_) | UpdateStatus::Failed(_) => true,
-        }
-    }
-
-    pub fn get_content_uuid(&self) -> Option<&Uuid> {
-        match &self.update {
-            UpdateStatus::Enqueued(enqueued) => enqueued.content.as_ref(),
-            UpdateStatus::Processing(processing) => processing.from.content.as_ref(),
-            UpdateStatus::Processed(processed) => processed.from.from.content.as_ref(),
-            UpdateStatus::Aborted(aborted) => aborted.from.content.as_ref(),
-            UpdateStatus::Failed(failed) => failed.from.from.content.as_ref(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub enum UpdateResult {
-    DocumentsAddition(DocumentAdditionResult),
-    DocumentDeletion { deleted: u64 },
-    Other,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct DocumentAdditionResult {
-    pub nb_documents: usize,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[non_exhaustive]
-pub enum IndexDocumentsMethod {
-    /// Replace the previous document with the new one,
-    /// removing all the already known attributes.
-    ReplaceDocuments,
-
-    /// Merge the previous version of the document with the new version,
-    /// replacing old attributes values with the new ones and add the new attributes.
-    UpdateDocuments,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[non_exhaustive]
-pub enum UpdateFormat {
-    /// The given update is a real **comma seperated** CSV with headers on the first line.
-    Csv,
-    /// The given update is a JSON array with documents inside.
-    Json,
-    /// The given update is a JSON stream with a document on each line.
-    JsonStream,
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Debug, Clone, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(tag = "type")]
-pub enum UpdateMeta {
-    DocumentsAddition {
-        method: IndexDocumentsMethod,
-        format: UpdateFormat,
-        primary_key: Option<String>,
-    },
-    ClearDocuments,
-    DeleteDocuments {
-        ids: Vec<String>,
-    },
-    Settings(Settings<Unchecked>),
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Enqueued {
-    pub update_id: u64,
-    pub meta: UpdateMeta,
-    #[serde(with = "time::serde::rfc3339")]
-    pub enqueued_at: OffsetDateTime,
-    pub content: Option<Uuid>,
-}
-
-impl Enqueued {
-    pub fn meta(&self) -> &UpdateMeta {
-        &self.meta
-    }
-
-    pub fn id(&self) -> u64 {
-        self.update_id
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Processed {
-    pub success: UpdateResult,
-    #[serde(with = "time::serde::rfc3339")]
-    pub processed_at: OffsetDateTime,
-    #[serde(flatten)]
-    pub from: Processing,
-}
-
-impl Processed {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &UpdateMeta {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Processing {
-    #[serde(flatten)]
-    pub from: Enqueued,
-    #[serde(with = "time::serde::rfc3339")]
-    pub started_processing_at: OffsetDateTime,
-}
-
-impl Processing {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &UpdateMeta {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Aborted {
-    #[serde(flatten)]
-    pub from: Enqueued,
-    #[serde(with = "time::serde::rfc3339")]
-    pub aborted_at: OffsetDateTime,
-}
-
-impl Aborted {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &UpdateMeta {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Failed {
-    #[serde(flatten)]
-    pub from: Processing,
-    pub error: ResponseError,
-    #[serde(with = "time::serde::rfc3339")]
-    pub failed_at: OffsetDateTime,
-}
-
-impl Failed {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &UpdateMeta {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(tag = "status", rename_all = "camelCase")]
-pub enum UpdateStatus {
-    Processing(Processing),
-    Enqueued(Enqueued),
-    Processed(Processed),
-    Aborted(Aborted),
-    Failed(Failed),
-}
-
-impl UpdateStatus {
-    pub fn id(&self) -> u64 {
-        match self {
-            UpdateStatus::Processing(u) => u.id(),
-            UpdateStatus::Enqueued(u) => u.id(),
-            UpdateStatus::Processed(u) => u.id(),
-            UpdateStatus::Aborted(u) => u.id(),
-            UpdateStatus::Failed(u) => u.id(),
-        }
-    }
-
-    pub fn meta(&self) -> &UpdateMeta {
-        match self {
-            UpdateStatus::Processing(u) => u.meta(),
-            UpdateStatus::Enqueued(u) => u.meta(),
-            UpdateStatus::Processed(u) => u.meta(),
-            UpdateStatus::Aborted(u) => u.meta(),
-            UpdateStatus::Failed(u) => u.meta(),
-        }
-    }
-
-    pub fn processed(&self) -> Option<&Processed> {
-        match self {
-            UpdateStatus::Processed(p) => Some(p),
-            _ => None,
-        }
-    }
-}

dump/src/reader/v3/errors.rs

@@ -1,51 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub enum Code {
-    // index related error
-    CreateIndex,
-    IndexAlreadyExists,
-    IndexNotFound,
-    InvalidIndexUid,
-
-    // invalid state error
-    InvalidState,
-    MissingPrimaryKey,
-    PrimaryKeyAlreadyPresent,
-
-    MaxFieldsLimitExceeded,
-    MissingDocumentId,
-    InvalidDocumentId,
-
-    Filter,
-    Sort,
-
-    BadParameter,
-    BadRequest,
-    DatabaseSizeLimitReached,
-    DocumentNotFound,
-    Internal,
-    InvalidGeoField,
-    InvalidRankingRule,
-    InvalidStore,
-    InvalidToken,
-    MissingAuthorizationHeader,
-    NoSpaceLeftOnDevice,
-    DumpNotFound,
-    TaskNotFound,
-    PayloadTooLarge,
-    RetrieveDocument,
-    SearchDocuments,
-    UnsupportedMediaType,
-
-    DumpAlreadyInProgress,
-    DumpProcessFailed,
-
-    InvalidContentType,
-    MissingContentType,
-    MalformedPayload,
-    MissingPayload,
-
-    MalformedDump,
-    UnretrievableErrorCode,
-}

dump/src/reader/v3/meta.rs

@@ -1,18 +0,0 @@
-use serde::Deserialize;
-use uuid::Uuid;
-
-use super::Settings;
-
-#[derive(Deserialize, Debug, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct IndexUuid {
-    pub uid: String,
-    pub uuid: Uuid,
-}
-
-#[derive(Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct DumpMeta {
-    pub settings: Settings<super::Unchecked>,
-    pub primary_key: Option<String>,
-}

dump/src/reader/v3/mod.rs

@@ -1,325 +0,0 @@
-//! ```text
-//! .
-//! ├── indexes
-//! │   ├── 01d7dd17-8241-4f1f-a7d1-2d1cb255f5b0
-//! │   │   ├── documents.jsonl
-//! │   │   └── meta.json
-//! │   ├── 78be64a3-cae1-449e-b7ed-13e77c9a8a0c
-//! │   │   ├── documents.jsonl
-//! │   │   └── meta.json
-//! │   ├── ba553439-18fe-4733-ba53-44eed898280c
-//! │   │   ├── documents.jsonl
-//! │   │   └── meta.json
-//! │   └── c408bc22-5859-49d1-8e9f-c88e2fa95cb0
-//! │       ├── documents.jsonl
-//! │       └── meta.json
-//! ├── index_uuids
-//! │   └── data.jsonl
-//! ├── metadata.json
-//! └── updates
-//!     ├── data.jsonl
-//!     └── updates_files
-//!         └── 66d3f12d-fcf3-4b53-88cb-407017373de7
-//! ```
-
-use std::fs::{self, File};
-use std::io::{BufRead, BufReader};
-use std::path::Path;
-
-use serde::{Deserialize, Serialize};
-use tempfile::TempDir;
-use time::OffsetDateTime;
-
-pub mod errors;
-pub mod meta;
-pub mod settings;
-pub mod updates;
-
-use self::meta::{DumpMeta, IndexUuid};
-use super::compat::v3_to_v4::CompatV3ToV4;
-use super::Document;
-use crate::{Error, IndexMetadata, Result, Version};
-
-pub type Settings<T> = settings::Settings<T>;
-pub type Checked = settings::Checked;
-pub type Unchecked = settings::Unchecked;
-
-pub type Task = updates::UpdateEntry;
-
-// ===== Other types to clarify the code of the compat module
-// everything related to the tasks
-pub type Status = updates::UpdateStatus;
-pub type Kind = updates::Update;
-
-// everything related to the settings
-pub type Setting<T> = settings::Setting<T>;
-
-// everything related to the errors
-pub type Code = errors::Code;
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Metadata {
-    db_version: String,
-    index_db_size: usize,
-    update_db_size: usize,
-    #[serde(with = "time::serde::rfc3339")]
-    dump_date: OffsetDateTime,
-}
-
-pub struct V3Reader {
-    dump: TempDir,
-    metadata: Metadata,
-    tasks: BufReader<File>,
-    index_uuid: Vec<IndexUuid>,
-}
-
-impl V3Reader {
-    pub fn open(dump: TempDir) -> Result<Self> {
-        let meta_file = fs::read(dump.path().join("metadata.json"))?;
-        let metadata = serde_json::from_reader(&*meta_file)?;
-        let index_uuid = File::open(dump.path().join("index_uuids/data.jsonl"))?;
-        let index_uuid = BufReader::new(index_uuid);
-        let index_uuid = index_uuid
-            .lines()
-            .map(|line| -> Result<_> { Ok(serde_json::from_str(&line?)?) })
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(V3Reader {
-            metadata,
-            tasks: BufReader::new(File::open(dump.path().join("updates").join("data.jsonl"))?),
-            index_uuid,
-            dump,
-        })
-    }
-
-    pub fn index_uuid(&self) -> Vec<IndexUuid> {
-        self.index_uuid.clone()
-    }
-
-    pub fn to_v4(self) -> CompatV3ToV4 {
-        CompatV3ToV4::new(self)
-    }
-
-    pub fn version(&self) -> Version {
-        Version::V3
-    }
-
-    pub fn date(&self) -> Option<OffsetDateTime> {
-        Some(self.metadata.dump_date)
-    }
-
-    pub fn indexes(&self) -> Result<impl Iterator<Item = Result<V3IndexReader>> + '_> {
-        Ok(self.index_uuid.iter().map(|index| -> Result<_> {
-            V3IndexReader::new(
-                index.uid.clone(),
-                &self.dump.path().join("indexes").join(index.uuid.to_string()),
-            )
-        }))
-    }
-
-    pub fn tasks(
-        &mut self,
-    ) -> Box<dyn Iterator<Item = Result<(Task, Option<Box<super::UpdateFile>>)>> + '_> {
-        Box::new((&mut self.tasks).lines().map(|line| -> Result<_> {
-            let task: Task = serde_json::from_str(&line?)?;
-            if !task.is_finished() {
-                if let Some(uuid) = task.get_content_uuid() {
-                    let update_file_path = self
-                        .dump
-                        .path()
-                        .join("updates")
-                        .join("updates_files")
-                        .join(uuid.to_string());
-                    Ok((
-                        task,
-                        Some(
-                            Box::new(UpdateFile::new(&update_file_path)?) as Box<super::UpdateFile>
-                        ),
-                    ))
-                } else {
-                    Ok((task, None))
-                }
-            } else {
-                Ok((task, None))
-            }
-        }))
-    }
-}
-
-pub struct V3IndexReader {
-    metadata: IndexMetadata,
-    settings: Settings<Checked>,
-
-    documents: BufReader<File>,
-}
-
-impl V3IndexReader {
-    pub fn new(name: String, path: &Path) -> Result<Self> {
-        let meta = File::open(path.join("meta.json"))?;
-        let meta: DumpMeta = serde_json::from_reader(meta)?;
-
-        let metadata = IndexMetadata {
-            uid: name,
-            primary_key: meta.primary_key,
-            // FIXME: Iterate over the whole task queue to find the creation and last update date.
-            created_at: OffsetDateTime::now_utc(),
-            updated_at: OffsetDateTime::now_utc(),
-        };
-
-        let ret = V3IndexReader {
-            metadata,
-            settings: meta.settings.check(),
-            documents: BufReader::new(File::open(path.join("documents.jsonl"))?),
-        };
-
-        Ok(ret)
-    }
-
-    pub fn metadata(&self) -> &IndexMetadata {
-        &self.metadata
-    }
-
-    pub fn documents(&mut self) -> Result<impl Iterator<Item = Result<Document>> + '_> {
-        Ok((&mut self.documents)
-            .lines()
-            .map(|line| -> Result<_> { Ok(serde_json::from_str(&line?)?) }))
-    }
-
-    pub fn settings(&mut self) -> Result<Settings<Checked>> {
-        Ok(self.settings.clone())
-    }
-}
-
-pub struct UpdateFile {
-    reader: BufReader<File>,
-}
-
-impl UpdateFile {
-    fn new(path: &Path) -> Result<Self> {
-        Ok(UpdateFile { reader: BufReader::new(File::open(path)?) })
-    }
-}
-
-impl Iterator for UpdateFile {
-    type Item = Result<Document>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        (&mut self.reader)
-            .lines()
-            .map(|line| {
-                line.map_err(Error::from)
-                    .and_then(|line| serde_json::from_str(&line).map_err(Error::from))
-            })
-            .next()
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use std::fs::File;
-    use std::io::BufReader;
-
-    use flate2::bufread::GzDecoder;
-    use meili_snap::insta;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn read_dump_v3() {
-        let dump = File::open("tests/assets/v3.dump").unwrap();
-        let dir = TempDir::new().unwrap();
-        let mut dump = BufReader::new(dump);
-        let gz = GzDecoder::new(&mut dump);
-        let mut archive = tar::Archive::new(gz);
-        archive.unpack(dir.path()).unwrap();
-
-        let mut dump = V3Reader::open(dir).unwrap();
-
-        // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
-
-        // tasks
-        let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
-        let (tasks, mut update_files): (Vec<_>, Vec<_>) = tasks.into_iter().unzip();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(tasks), @"63086d59c3f2074e4ab3fff7e8cc36c1");
-        assert_eq!(update_files.len(), 10);
-        assert!(update_files[0].is_some()); // the enqueued document addition
-        assert!(update_files[1..].iter().all(|u| u.is_none())); // everything already processed
-
-        let update_file = update_files.remove(0).unwrap().collect::<Result<Vec<_>>>().unwrap();
-        meili_snap::snapshot_hash!(meili_snap::json_string!(update_file), @"7b8889539b669c7b9ddba448bafa385d");
-
-        // indexes
-        let mut indexes = dump.indexes().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        // the index are not ordered in any way by default
-        indexes.sort_by_key(|index| index.metadata().uid.to_string());
-
-        let mut products = indexes.pop().unwrap();
-        let mut movies2 = indexes.pop().unwrap();
-        let mut movies = indexes.pop().unwrap();
-        let mut spells = indexes.pop().unwrap();
-        assert!(indexes.is_empty());
-
-        // products
-        insta::assert_json_snapshot!(products.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "products",
-          "primaryKey": "sku",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(products.settings().unwrap());
-        let documents = products.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"548284a84de510f71e88e6cdea495cf5");
-
-        // movies
-        insta::assert_json_snapshot!(movies.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies",
-          "primaryKey": "id",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies.settings().unwrap());
-        let documents = movies.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 110);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d153b5a81d8b3cdcbe1dec270b574022");
-
-        // movies2
-        insta::assert_json_snapshot!(movies2.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "movies_2",
-          "primaryKey": null,
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(movies2.settings().unwrap());
-        let documents = movies2.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 0);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"d751713988987e9331980363e24189ce");
-
-        // spells
-        insta::assert_json_snapshot!(spells.metadata(), { ".createdAt" => "[now]", ".updatedAt" => "[now]" }, @r###"
-        {
-          "uid": "dnd_spells",
-          "primaryKey": "index",
-          "createdAt": "[now]",
-          "updatedAt": "[now]"
-        }
-        "###);
-
-        insta::assert_json_snapshot!(spells.settings().unwrap());
-        let documents = spells.documents().unwrap().collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(documents.len(), 10);
-        meili_snap::snapshot_hash!(format!("{:#?}", documents), @"235016433dd04262c7f2da01d1e808ce");
-    }
-}

dump/src/reader/v3/settings.rs

@@ -1,233 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-use std::marker::PhantomData;
-use std::num::NonZeroUsize;
-
-use serde::{Deserialize, Deserializer};
-
-#[cfg(test)]
-fn serialize_with_wildcard<S>(
-    field: &Setting<Vec<String>>,
-    s: S,
-) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    use serde::Serialize;
-
-    let wildcard = vec!["*".to_string()];
-    match field {
-        Setting::Set(value) => Some(value),
-        Setting::Reset => Some(&wildcard),
-        Setting::NotSet => None,
-    }
-    .serialize(s)
-}
-
-#[derive(Clone, Default, Debug)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct Checked;
-
-#[derive(Clone, Default, Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct Unchecked;
-
-/// Holds all the settings for an index. `T` can either be `Checked` if they represents settings
-/// whose validity is guaranteed, or `Unchecked` if they need to be validated. In the later case, a
-/// call to `check` will return a `Settings<Checked>` from a `Settings<Unchecked>`.
-#[derive(Debug, Clone, Default, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(deny_unknown_fields)]
-#[serde(rename_all = "camelCase")]
-#[serde(bound(serialize = "T: serde::Serialize", deserialize = "T: Deserialize<'static>"))]
-pub struct Settings<T> {
-    #[serde(
-        default,
-        serialize_with = "serialize_with_wildcard",
-        skip_serializing_if = "Setting::is_not_set"
-    )]
-    pub displayed_attributes: Setting<Vec<String>>,
-
-    #[serde(
-        default,
-        serialize_with = "serialize_with_wildcard",
-        skip_serializing_if = "Setting::is_not_set"
-    )]
-    pub searchable_attributes: Setting<Vec<String>>,
-
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub filterable_attributes: Setting<BTreeSet<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub sortable_attributes: Setting<BTreeSet<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub ranking_rules: Setting<Vec<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub stop_words: Setting<BTreeSet<String>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub synonyms: Setting<BTreeMap<String, Vec<String>>>,
-    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
-    pub distinct_attribute: Setting<String>,
-
-    #[serde(skip)]
-    pub _kind: PhantomData<T>,
-}
-
-impl Settings<Checked> {
-    pub fn cleared() -> Settings<Checked> {
-        Settings {
-            displayed_attributes: Setting::Reset,
-            searchable_attributes: Setting::Reset,
-            filterable_attributes: Setting::Reset,
-            sortable_attributes: Setting::Reset,
-            ranking_rules: Setting::Reset,
-            stop_words: Setting::Reset,
-            synonyms: Setting::Reset,
-            distinct_attribute: Setting::Reset,
-            _kind: PhantomData,
-        }
-    }
-
-    pub fn into_unchecked(self) -> Settings<Unchecked> {
-        let Self {
-            displayed_attributes,
-            searchable_attributes,
-            filterable_attributes,
-            sortable_attributes,
-            ranking_rules,
-            stop_words,
-            synonyms,
-            distinct_attribute,
-            ..
-        } = self;
-
-        Settings {
-            displayed_attributes,
-            searchable_attributes,
-            filterable_attributes,
-            sortable_attributes,
-            ranking_rules,
-            stop_words,
-            synonyms,
-            distinct_attribute,
-            _kind: PhantomData,
-        }
-    }
-}
-
-impl Settings<Unchecked> {
-    pub fn check(self) -> Settings<Checked> {
-        let displayed_attributes = match self.displayed_attributes {
-            Setting::Set(fields) => {
-                if fields.iter().any(|f| f == "*") {
-                    Setting::Reset
-                } else {
-                    Setting::Set(fields)
-                }
-            }
-            otherwise => otherwise,
-        };
-
-        let searchable_attributes = match self.searchable_attributes {
-            Setting::Set(fields) => {
-                if fields.iter().any(|f| f == "*") {
-                    Setting::Reset
-                } else {
-                    Setting::Set(fields)
-                }
-            }
-            otherwise => otherwise,
-        };
-
-        Settings {
-            displayed_attributes,
-            searchable_attributes,
-            filterable_attributes: self.filterable_attributes,
-            sortable_attributes: self.sortable_attributes,
-            ranking_rules: self.ranking_rules,
-            stop_words: self.stop_words,
-            synonyms: self.synonyms,
-            distinct_attribute: self.distinct_attribute,
-            _kind: PhantomData,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(deny_unknown_fields)]
-#[serde(rename_all = "camelCase")]
-pub struct Facets {
-    pub level_group_size: Option<NonZeroUsize>,
-    pub min_level_size: Option<NonZeroUsize>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Setting<T> {
-    Set(T),
-    Reset,
-    NotSet,
-}
-
-impl<T> Default for Setting<T> {
-    fn default() -> Self {
-        Self::NotSet
-    }
-}
-
-impl<T> Setting<T> {
-    pub fn map<U, F>(self, f: F) -> Setting<U>
-    where
-        F: FnOnce(T) -> U,
-    {
-        match self {
-            Setting::Set(t) => Setting::Set(f(t)),
-            Setting::Reset => Setting::Reset,
-            Setting::NotSet => Setting::NotSet,
-        }
-    }
-
-    pub fn set(self) -> Option<T> {
-        match self {
-            Self::Set(value) => Some(value),
-            _ => None,
-        }
-    }
-
-    pub const fn as_ref(&self) -> Setting<&T> {
-        match *self {
-            Self::Set(ref value) => Setting::Set(value),
-            Self::Reset => Setting::Reset,
-            Self::NotSet => Setting::NotSet,
-        }
-    }
-
-    pub const fn is_not_set(&self) -> bool {
-        matches!(self, Self::NotSet)
-    }
-}
-
-#[cfg(test)]
-impl<T: serde::Serialize> serde::Serialize for Setting<T> {
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self {
-            Self::Set(value) => Some(value),
-            // Usually not_set isn't serialized by setting skip_serializing_if field attribute
-            Self::NotSet | Self::Reset => None,
-        }
-        .serialize(serializer)
-    }
-}
-
-impl<'de, T: Deserialize<'de>> Deserialize<'de> for Setting<T> {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Deserialize::deserialize(deserializer).map(|x| match x {
-            Some(x) => Self::Set(x),
-            None => Self::Reset, // Reset is forced by sending null value
-        })
-    }
-}

dump/src/reader/v3/snapshots/dump__reader__v3__test__read_dump_v3-11.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/v3/mod.rs
-expression: movies2.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v3/snapshots/dump__reader__v3__test__read_dump_v3-14.snap

@@ -1,25 +0,0 @@
----
-source: dump/src/reader/v3/mod.rs
-expression: spells.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v3/snapshots/dump__reader__v3__test__read_dump_v3-5.snap

@@ -1,39 +0,0 @@
----
-source: dump/src/reader/v3/mod.rs
-expression: products.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [],
-  "sortableAttributes": [],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness"
-  ],
-  "stopWords": [],
-  "synonyms": {
-    "android": [
-      "phone",
-      "smartphone"
-    ],
-    "iphone": [
-      "phone",
-      "smartphone"
-    ],
-    "phone": [
-      "android",
-      "iphone",
-      "smartphone"
-    ]
-  },
-  "distinctAttribute": null
-}

dump/src/reader/v3/snapshots/dump__reader__v3__test__read_dump_v3-8.snap

@@ -1,31 +0,0 @@
----
-source: dump/src/reader/v3/mod.rs
-expression: movies.settings().unwrap()
----
-{
-  "displayedAttributes": [
-    "*"
-  ],
-  "searchableAttributes": [
-    "*"
-  ],
-  "filterableAttributes": [
-    "genres",
-    "id"
-  ],
-  "sortableAttributes": [
-    "release_date"
-  ],
-  "rankingRules": [
-    "words",
-    "typo",
-    "proximity",
-    "attribute",
-    "sort",
-    "exactness",
-    "release_date:asc"
-  ],
-  "stopWords": [],
-  "synonyms": {},
-  "distinctAttribute": null
-}

dump/src/reader/v3/updates.rs

@@ -1,227 +0,0 @@
-use std::fmt::Display;
-
-use serde::Deserialize;
-use time::OffsetDateTime;
-use uuid::Uuid;
-
-use super::{Code, Settings, Unchecked};
-
-#[derive(Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct UpdateEntry {
-    pub uuid: Uuid,
-    pub update: UpdateStatus,
-}
-
-impl UpdateEntry {
-    pub fn is_finished(&self) -> bool {
-        match self.update {
-            UpdateStatus::Processed(_) | UpdateStatus::Aborted(_) | UpdateStatus::Failed(_) => true,
-            UpdateStatus::Processing(_) | UpdateStatus::Enqueued(_) => false,
-        }
-    }
-
-    pub fn get_content_uuid(&self) -> Option<&Uuid> {
-        match self.update.meta() {
-            Update::DocumentAddition { content_uuid, .. } => Some(content_uuid),
-            Update::DeleteDocuments(_) | Update::Settings(_) | Update::ClearDocuments => None,
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(tag = "status", rename_all = "camelCase")]
-pub enum UpdateStatus {
-    Processing(Processing),
-    Enqueued(Enqueued),
-    Processed(Processed),
-    Aborted(Aborted),
-    Failed(Failed),
-}
-
-impl UpdateStatus {
-    pub fn id(&self) -> u64 {
-        match self {
-            UpdateStatus::Processing(u) => u.id(),
-            UpdateStatus::Enqueued(u) => u.id(),
-            UpdateStatus::Processed(u) => u.id(),
-            UpdateStatus::Aborted(u) => u.id(),
-            UpdateStatus::Failed(u) => u.id(),
-        }
-    }
-
-    pub fn meta(&self) -> &Update {
-        match self {
-            UpdateStatus::Processing(u) => u.meta(),
-            UpdateStatus::Enqueued(u) => u.meta(),
-            UpdateStatus::Processed(u) => u.meta(),
-            UpdateStatus::Aborted(u) => u.meta(),
-            UpdateStatus::Failed(u) => u.meta(),
-        }
-    }
-
-    pub fn is_finished(&self) -> bool {
-        match self {
-            UpdateStatus::Processing(_) | UpdateStatus::Enqueued(_) => false,
-            UpdateStatus::Aborted(_) | UpdateStatus::Failed(_) | UpdateStatus::Processed(_) => true,
-        }
-    }
-
-    pub fn processed(&self) -> Option<&Processed> {
-        match self {
-            UpdateStatus::Processed(p) => Some(p),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Enqueued {
-    pub update_id: u64,
-    pub meta: Update,
-    #[serde(with = "time::serde::rfc3339")]
-    pub enqueued_at: OffsetDateTime,
-}
-
-impl Enqueued {
-    pub fn meta(&self) -> &Update {
-        &self.meta
-    }
-
-    pub fn id(&self) -> u64 {
-        self.update_id
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Processed {
-    pub success: UpdateResult,
-    #[serde(with = "time::serde::rfc3339")]
-    pub processed_at: OffsetDateTime,
-    #[serde(flatten)]
-    pub from: Processing,
-}
-
-impl Processed {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &Update {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Processing {
-    #[serde(flatten)]
-    pub from: Enqueued,
-    #[serde(with = "time::serde::rfc3339")]
-    pub started_processing_at: OffsetDateTime,
-}
-
-impl Processing {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &Update {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Aborted {
-    #[serde(flatten)]
-    pub from: Enqueued,
-    #[serde(with = "time::serde::rfc3339")]
-    pub aborted_at: OffsetDateTime,
-}
-
-impl Aborted {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &Update {
-        self.from.meta()
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[serde(rename_all = "camelCase")]
-pub struct Failed {
-    #[serde(flatten)]
-    pub from: Processing,
-    pub msg: String,
-    pub code: Code,
-    #[serde(with = "time::serde::rfc3339")]
-    pub failed_at: OffsetDateTime,
-}
-
-impl Display for Failed {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.msg.fmt(f)
-    }
-}
-
-impl Failed {
-    pub fn id(&self) -> u64 {
-        self.from.id()
-    }
-
-    pub fn meta(&self) -> &Update {
-        self.from.meta()
-    }
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Debug, Clone, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub enum Update {
-    DeleteDocuments(Vec<String>),
-    DocumentAddition {
-        primary_key: Option<String>,
-        method: IndexDocumentsMethod,
-        content_uuid: Uuid,
-    },
-    Settings(Settings<Unchecked>),
-    ClearDocuments,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[non_exhaustive]
-pub enum IndexDocumentsMethod {
-    /// Replace the previous document with the new one,
-    /// removing all the already known attributes.
-    ReplaceDocuments,
-
-    /// Merge the previous version of the document with the new version,
-    /// replacing old attributes values with the new ones and add the new attributes.
-    UpdateDocuments,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub enum UpdateResult {
-    DocumentsAddition(DocumentAdditionResult),
-    DocumentDeletion { deleted: u64 },
-    Other,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct DocumentAdditionResult {
-    pub nb_documents: usize,
-}

dump/src/reader/v4/errors.rs

@@ -1,309 +0,0 @@
-use std::fmt;
-
-use http::StatusCode;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct ResponseError {
-    #[serde(skip)]
-    pub code: StatusCode,
-    pub message: String,
-    #[serde(rename = "code")]
-    pub error_code: String,
-    #[serde(rename = "type")]
-    pub error_type: String,
-    #[serde(rename = "link")]
-    pub error_link: String,
-}
-
-impl ResponseError {
-    pub fn from_msg(message: String, code: Code) -> Self {
-        Self {
-            code: code.http(),
-            message,
-            error_code: code.err_code().error_name.to_string(),
-            error_type: code.type_(),
-            error_link: code.url(),
-        }
-    }
-}
-
-impl fmt::Display for ResponseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.message.fmt(f)
-    }
-}
-
-impl std::error::Error for ResponseError {}
-
-impl<T> From<T> for ResponseError
-where
-    T: ErrorCode,
-{
-    fn from(other: T) -> Self {
-        Self {
-            code: other.http_status(),
-            message: other.to_string(),
-            error_code: other.error_name(),
-            error_type: other.error_type(),
-            error_link: other.error_url(),
-        }
-    }
-}
-
-pub trait ErrorCode: std::error::Error {
-    fn error_code(&self) -> Code;
-
-    /// returns the HTTP status code ascociated with the error
-    fn http_status(&self) -> StatusCode {
-        self.error_code().http()
-    }
-
-    /// returns the doc url ascociated with the error
-    fn error_url(&self) -> String {
-        self.error_code().url()
-    }
-
-    /// returns error name, used as error code
-    fn error_name(&self) -> String {
-        self.error_code().name()
-    }
-
-    /// return the error type
-    fn error_type(&self) -> String {
-        self.error_code().type_()
-    }
-}
-
-#[allow(clippy::enum_variant_names)]
-enum ErrorType {
-    InternalError,
-    InvalidRequestError,
-    AuthenticationError,
-}
-
-impl fmt::Display for ErrorType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use ErrorType::*;
-
-        match self {
-            InternalError => write!(f, "internal"),
-            InvalidRequestError => write!(f, "invalid_request"),
-            AuthenticationError => write!(f, "auth"),
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub enum Code {
-    // index related error
-    CreateIndex,
-    IndexAlreadyExists,
-    IndexNotFound,
-    InvalidIndexUid,
-    InvalidMinWordLengthForTypo,
-
-    // invalid state error
-    InvalidState,
-    MissingPrimaryKey,
-    PrimaryKeyAlreadyPresent,
-
-    MaxFieldsLimitExceeded,
-    MissingDocumentId,
-    InvalidDocumentId,
-
-    Filter,
-    Sort,
-
-    BadParameter,
-    BadRequest,
-    DatabaseSizeLimitReached,
-    DocumentNotFound,
-    Internal,
-    InvalidGeoField,
-    InvalidRankingRule,
-    InvalidStore,
-    InvalidToken,
-    MissingAuthorizationHeader,
-    NoSpaceLeftOnDevice,
-    DumpNotFound,
-    TaskNotFound,
-    PayloadTooLarge,
-    RetrieveDocument,
-    SearchDocuments,
-    UnsupportedMediaType,
-
-    DumpAlreadyInProgress,
-    DumpProcessFailed,
-
-    InvalidContentType,
-    MissingContentType,
-    MalformedPayload,
-    MissingPayload,
-
-    ApiKeyNotFound,
-    MissingParameter,
-    InvalidApiKeyActions,
-    InvalidApiKeyIndexes,
-    InvalidApiKeyExpiresAt,
-    InvalidApiKeyDescription,
-
-    UnretrievableErrorCode,
-    MalformedDump,
-}
-
-impl Code {
-    /// ascociate a `Code` variant to the actual ErrCode
-    fn err_code(&self) -> ErrCode {
-        use Code::*;
-
-        match self {
-            // index related errors
-            // create index is thrown on internal error while creating an index.
-            CreateIndex => {
-                ErrCode::internal("index_creation_failed", StatusCode::INTERNAL_SERVER_ERROR)
-            }
-            IndexAlreadyExists => ErrCode::invalid("index_already_exists", StatusCode::CONFLICT),
-            // thrown when requesting an unexisting index
-            IndexNotFound => ErrCode::invalid("index_not_found", StatusCode::NOT_FOUND),
-            InvalidIndexUid => ErrCode::invalid("invalid_index_uid", StatusCode::BAD_REQUEST),
-
-            // invalid state error
-            InvalidState => ErrCode::internal("invalid_state", StatusCode::INTERNAL_SERVER_ERROR),
-            // thrown when no primary key has been set
-            MissingPrimaryKey => {
-                ErrCode::invalid("primary_key_inference_failed", StatusCode::BAD_REQUEST)
-            }
-            // error thrown when trying to set an already existing primary key
-            PrimaryKeyAlreadyPresent => {
-                ErrCode::invalid("index_primary_key_already_exists", StatusCode::BAD_REQUEST)
-            }
-            // invalid ranking rule
-            InvalidRankingRule => ErrCode::invalid("invalid_ranking_rule", StatusCode::BAD_REQUEST),
-
-            // invalid database
-            InvalidStore => {
-                ErrCode::internal("invalid_store_file", StatusCode::INTERNAL_SERVER_ERROR)
-            }
-
-            // invalid document
-            MaxFieldsLimitExceeded => {
-                ErrCode::invalid("max_fields_limit_exceeded", StatusCode::BAD_REQUEST)
-            }
-            MissingDocumentId => ErrCode::invalid("missing_document_id", StatusCode::BAD_REQUEST),
-            InvalidDocumentId => ErrCode::invalid("invalid_document_id", StatusCode::BAD_REQUEST),
-
-            // error related to filters
-            Filter => ErrCode::invalid("invalid_filter", StatusCode::BAD_REQUEST),
-            // error related to sorts
-            Sort => ErrCode::invalid("invalid_sort", StatusCode::BAD_REQUEST),
-
-            BadParameter => ErrCode::invalid("bad_parameter", StatusCode::BAD_REQUEST),
-            BadRequest => ErrCode::invalid("bad_request", StatusCode::BAD_REQUEST),
-            DatabaseSizeLimitReached => {
-                ErrCode::internal("database_size_limit_reached", StatusCode::INTERNAL_SERVER_ERROR)
-            }
-            DocumentNotFound => ErrCode::invalid("document_not_found", StatusCode::NOT_FOUND),
-            Internal => ErrCode::internal("internal", StatusCode::INTERNAL_SERVER_ERROR),
-            InvalidGeoField => ErrCode::invalid("invalid_geo_field", StatusCode::BAD_REQUEST),
-            InvalidToken => ErrCode::authentication("invalid_api_key", StatusCode::FORBIDDEN),
-            MissingAuthorizationHeader => {
-                ErrCode::authentication("missing_authorization_header", StatusCode::UNAUTHORIZED)
-            }
-            TaskNotFound => ErrCode::invalid("task_not_found", StatusCode::NOT_FOUND),
-            DumpNotFound => ErrCode::invalid("dump_not_found", StatusCode::NOT_FOUND),
-            NoSpaceLeftOnDevice => {
-                ErrCode::internal("no_space_left_on_device", StatusCode::INTERNAL_SERVER_ERROR)
-            }
-            PayloadTooLarge => ErrCode::invalid("payload_too_large", StatusCode::PAYLOAD_TOO_LARGE),
-            RetrieveDocument => {
-                ErrCode::internal("unretrievable_document", StatusCode::BAD_REQUEST)
-            }
-            SearchDocuments => ErrCode::internal("search_error", StatusCode::BAD_REQUEST),
-            UnsupportedMediaType => {
-                ErrCode::invalid("unsupported_media_type", StatusCode::UNSUPPORTED_MEDIA_TYPE)
-            }
-
-            // error related to dump
-            DumpAlreadyInProgress => {
-                ErrCode::invalid("dump_already_processing", StatusCode::CONFLICT)
-            }
-            DumpProcessFailed => {
-                ErrCode::internal("dump_process_failed", StatusCode::INTERNAL_SERVER_ERROR)
-            }
-            MissingContentType => {
-                ErrCode::invalid("missing_content_type", StatusCode::UNSUPPORTED_MEDIA_TYPE)
-            }
-            MalformedPayload => ErrCode::invalid("malformed_payload", StatusCode::BAD_REQUEST),
-            InvalidContentType => {
-                ErrCode::invalid("invalid_content_type", StatusCode::UNSUPPORTED_MEDIA_TYPE)
-            }
-            MissingPayload => ErrCode::invalid("missing_payload", StatusCode::BAD_REQUEST),
-
-            // error related to keys
-            ApiKeyNotFound => ErrCode::invalid("api_key_not_found", StatusCode::NOT_FOUND),
-            MissingParameter => ErrCode::invalid("missing_parameter", StatusCode::BAD_REQUEST),
-            InvalidApiKeyActions => {
-                ErrCode::invalid("invalid_api_key_actions", StatusCode::BAD_REQUEST)
-            }
-            InvalidApiKeyIndexes => {
-                ErrCode::invalid("invalid_api_key_indexes", StatusCode::BAD_REQUEST)
-            }
-            InvalidApiKeyExpiresAt => {
-                ErrCode::invalid("invalid_api_key_expires_at", StatusCode::BAD_REQUEST)
-            }
-            InvalidApiKeyDescription => {
-                ErrCode::invalid("invalid_api_key_description", StatusCode::BAD_REQUEST)
-            }
-            InvalidMinWordLengthForTypo => {
-                ErrCode::invalid("invalid_min_word_length_for_typo", StatusCode::BAD_REQUEST)
-            }
-            UnretrievableErrorCode => {
-                ErrCode::invalid("unretrievable_error_code", StatusCode::BAD_REQUEST)
-            }
-            MalformedDump => ErrCode::invalid("malformed_dump", StatusCode::BAD_REQUEST),
-        }
-    }
-
-    /// return the HTTP status code ascociated with the `Code`
-    fn http(&self) -> StatusCode {
-        self.err_code().status_code
-    }
-
-    /// return error name, used as error code
-    fn name(&self) -> String {
-        self.err_code().error_name.to_string()
-    }
-
-    /// return the error type
-    fn type_(&self) -> String {
-        self.err_code().error_type.to_string()
-    }
-
-    /// return the doc url ascociated with the error
-    fn url(&self) -> String {
-        format!("https://docs.meilisearch.com/errors#{}", self.name())
-    }
-}
-
-/// Internal structure providing a convenient way to create error codes
-struct ErrCode {
-    status_code: StatusCode,
-    error_type: ErrorType,
-    error_name: &'static str,
-}
-
-impl ErrCode {
-    fn authentication(error_name: &'static str, status_code: StatusCode) -> ErrCode {
-        ErrCode { status_code, error_name, error_type: ErrorType::AuthenticationError }
-    }
-
-    fn internal(error_name: &'static str, status_code: StatusCode) -> ErrCode {
-        ErrCode { status_code, error_name, error_type: ErrorType::InternalError }
-    }
-
-    fn invalid(error_name: &'static str, status_code: StatusCode) -> ErrCode {
-        ErrCode { status_code, error_name, error_type: ErrorType::InvalidRequestError }
-    }
-}

dump/src/reader/v4/keys.rs

@@ -1,77 +0,0 @@
-use serde::Deserialize;
-use time::OffsetDateTime;
-
-pub const KEY_ID_LENGTH: usize = 8;
-pub type KeyId = [u8; KEY_ID_LENGTH];
-
-#[derive(Debug, Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct Key {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    pub id: KeyId,
-    pub actions: Vec<Action>,
-    pub indexes: Vec<String>,
-    #[serde(with = "time::serde::rfc3339::option")]
-    pub expires_at: Option<OffsetDateTime>,
-    #[serde(with = "time::serde::rfc3339")]
-    pub created_at: OffsetDateTime,
-    #[serde(with = "time::serde::rfc3339")]
-    pub updated_at: OffsetDateTime,
-}
-
-#[derive(Copy, Clone, Deserialize, Debug, Eq, PartialEq)]
-#[cfg_attr(test, derive(serde::Serialize))]
-#[repr(u8)]
-pub enum Action {
-    #[serde(rename = "*")]
-    All = 0,
-    #[serde(rename = "search")]
-    Search = actions::SEARCH,
-    #[serde(rename = "documents.add")]
-    DocumentsAdd = actions::DOCUMENTS_ADD,
-    #[serde(rename = "documents.get")]
-    DocumentsGet = actions::DOCUMENTS_GET,
-    #[serde(rename = "documents.delete")]
-    DocumentsDelete = actions::DOCUMENTS_DELETE,
-    #[serde(rename = "indexes.create")]
-    IndexesAdd = actions::INDEXES_CREATE,
-    #[serde(rename = "indexes.get")]
-    IndexesGet = actions::INDEXES_GET,
-    #[serde(rename = "indexes.update")]
-    IndexesUpdate = actions::INDEXES_UPDATE,
-    #[serde(rename = "indexes.delete")]
-    IndexesDelete = actions::INDEXES_DELETE,
-    #[serde(rename = "tasks.get")]
-    TasksGet = actions::TASKS_GET,
-    #[serde(rename = "settings.get")]
-    SettingsGet = actions::SETTINGS_GET,
-    #[serde(rename = "settings.update")]
-    SettingsUpdate = actions::SETTINGS_UPDATE,
-    #[serde(rename = "stats.get")]
-    StatsGet = actions::STATS_GET,
-    #[serde(rename = "dumps.create")]
-    DumpsCreate = actions::DUMPS_CREATE,
-    #[serde(rename = "dumps.get")]
-    DumpsGet = actions::DUMPS_GET,
-    #[serde(rename = "version")]
-    Version = actions::VERSION,
-}
-
-pub mod actions {
-    pub const SEARCH: u8 = 1;
-    pub const DOCUMENTS_ADD: u8 = 2;
-    pub const DOCUMENTS_GET: u8 = 3;
-    pub const DOCUMENTS_DELETE: u8 = 4;
-    pub const INDEXES_CREATE: u8 = 5;
-    pub const INDEXES_GET: u8 = 6;
-    pub const INDEXES_UPDATE: u8 = 7;
-    pub const INDEXES_DELETE: u8 = 8;
-    pub const TASKS_GET: u8 = 9;
-    pub const SETTINGS_GET: u8 = 10;
-    pub const SETTINGS_UPDATE: u8 = 11;
-    pub const STATS_GET: u8 = 12;
-    pub const DUMPS_CREATE: u8 = 13;
-    pub const DUMPS_GET: u8 = 14;
-    pub const VERSION: u8 = 15;
-}

dump/src/reader/v4/meta.rs

@@ -1,139 +0,0 @@
-use std::fmt::{self, Display, Formatter};
-use std::marker::PhantomData;
-use std::str::FromStr;
-
-use serde::de::Visitor;
-use serde::{Deserialize, Deserializer};
-use uuid::Uuid;
-
-use super::settings::{Settings, Unchecked};
-
-#[derive(Deserialize, Debug)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct IndexUuid {
-    pub uid: String,
-    pub index_meta: IndexMeta,
-}
-
-#[derive(Deserialize, Debug)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct IndexMeta {
-    pub uuid: Uuid,
-    pub creation_task_id: usize,
-}
-
-// There is one in each indexes under `meta.json`.
-#[derive(Deserialize)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct DumpMeta {
-    pub settings: Settings<Unchecked>,
-    pub primary_key: Option<String>,
-}
-
-#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub struct IndexUid(pub String);
-
-impl TryFrom<String> for IndexUid {
-    type Error = IndexUidFormatError;
-
-    fn try_from(uid: String) -> Result<Self, Self::Error> {
-        if !uid.chars().all(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_')
-            || uid.is_empty()
-            || uid.len() > 400
-        {
-            Err(IndexUidFormatError { invalid_uid: uid })
-        } else {
-            Ok(IndexUid(uid))
-        }
-    }
-}
-
-impl FromStr for IndexUid {
-    type Err = IndexUidFormatError;
-
-    fn from_str(uid: &str) -> Result<IndexUid, IndexUidFormatError> {
-        uid.to_string().try_into()
-    }
-}
-
-impl From<IndexUid> for String {
-    fn from(uid: IndexUid) -> Self {
-        uid.into_inner()
-    }
-}
-
-#[derive(Debug)]
-pub struct IndexUidFormatError {
-    pub invalid_uid: String,
-}
-
-impl Display for IndexUidFormatError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "invalid index uid `{}`, the uid must be an integer \
-            or a string containing only alphanumeric characters \
-            a-z A-Z 0-9, hyphens - and underscores _.",
-            self.invalid_uid,
-        )
-    }
-}
-
-impl std::error::Error for IndexUidFormatError {}
-
-/// A type that tries to match either a star (*) or
-/// any other thing that implements `FromStr`.
-#[derive(Debug)]
-#[cfg_attr(test, derive(serde::Serialize))]
-pub enum StarOr<T> {
-    Star,
-    Other(T),
-}
-
-impl<'de, T, E> Deserialize<'de> for StarOr<T>
-where
-    T: FromStr<Err = E>,
-    E: Display,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        /// Serde can't differentiate between `StarOr::Star` and `StarOr::Other` without a tag.
-        /// Simply using `#[serde(untagged)]` + `#[serde(rename="*")]` will lead to attempting to
-        /// deserialize everything as a `StarOr::Other`, including "*".
-        /// [`#[serde(other)]`](https://serde.rs/variant-attrs.html#other) might have helped but is
-        /// not supported on untagged enums.
-        struct StarOrVisitor<T>(PhantomData<T>);
-
-        impl<'de, T, FE> Visitor<'de> for StarOrVisitor<T>
-        where
-            T: FromStr<Err = FE>,
-            FE: Display,
-        {
-            type Value = StarOr<T>;
-
-            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
-                formatter.write_str("a string")
-            }
-
-            fn visit_str<SE>(self, v: &str) -> Result<Self::Value, SE>
-            where
-                SE: serde::de::Error,
-            {
-                match v {
-                    "*" => Ok(StarOr::Star),
-                    v => {
-                        let other = FromStr::from_str(v).map_err(|e: T::Err| {
-                            SE::custom(format!("Invalid `other` value: {}", e))
-                        })?;
-                        Ok(StarOr::Other(other))
-                    }
-                }
-            }
-        }
-
-        deserializer.deserialize_str(StarOrVisitor(PhantomData))
-    }
-}