39 Commits
Author SHA1 Message Date
venture d0957e90d0 release 1.0.0 : fin du périmètre V1
Release / release-apk (push) Successful in 9m23s
Release / release-docker (push) Successful in 38s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m23s
CI / lint-mobile (push) Failing after 7m45s
CI / test-backend (push) Successful in 1m24s
CI / test-mobile (push) Successful in 9m16s
CI / build-backend (push) Successful in 58s
2026-09-25 18:13:36 +02:00
venture a50eb830f4 consolidation V1 : docs resync, PDF streaming multi-pages, recherche sans accents, parser https 2026-09-25 18:13:30 +02:00
venture c642763035 api use
CI / lint-backend (push) Successful in 1m24s
CI / lint-mobile (push) Failing after 7m28s
CI / test-backend (push) Successful in 1m25s
CI / test-mobile (push) Successful in 9m9s
CI / build-backend (push) Successful in 45s
CI / docker (push) Successful in 33s
2026-09-25 17:34:35 +02:00
venture b869f70922 streaming d'un fichier 2026-09-25 15:34:28 +02:00
venture 9e8b01b135 chage floatting footer into scanned files
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Successful in 8m44s
CI / test-backend (push) Successful in 1m21s
CI / test-mobile (push) Successful in 8m55s
CI / build-backend (push) Successful in 45s
CI / docker (push) Successful in 9s
2026-09-25 14:09:12 +02:00
venture 456579880e improve documents
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Canceled after 5m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-25 14:02:41 +02:00
venture 25aedb431e hide sync status is local mode app
CI / lint-backend (push) Successful in 1m21s
CI / lint-mobile (push) Successful in 20m43s
CI / test-backend (push) Successful in 1m50s
CI / test-mobile (push) Successful in 8m49s
CI / build-backend (push) Successful in 45s
CI / docker (push) Successful in 3m50s
2026-09-25 12:09:14 +02:00
venture 25bab43b21 split serveur config and login
CI / lint-backend (push) Successful in 1m42s
CI / lint-mobile (push) Canceled after 5m5s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-25 12:02:23 +02:00
venture cbc94c8722 feat(mobile): refonte UI phases 0-4 + nav sans transitions
CI / lint-backend (push) Successful in 1m37s
CI / lint-mobile (push) Successful in 11m18s
CI / test-backend (push) Successful in 1m34s
CI / test-mobile (push) Successful in 13m11s
CI / build-backend (push) Successful in 1m6s
CI / docker (push) Successful in 9s
- Phase 0: design system (Color/Theme/Type complets light/dark,
  Shapes/Dimens, KazierCard, formatFileSize centralise)
- Phase 1: composants partages sur colorScheme (badges, dialogs,
  nav flottante factorisee, contentDescriptions)
- Phase 2: ecrans principaux (cartes unifiees, boutons M3,
  LoginForm partage, recherche avec compteur/clear)
- Phase 3: flows secondaires (dashboard sync, review animee,
  scan 360dp + sortie cul-de-sac camera, PdfBuilder checkbox/
  recherche/fin auto-nav, share ExposedDropdownMenu + confirmation,
  watched rescan + erreur import)
- Phase 4: a11y (selection semantics), dialogs saveable, cibles 48dp
- NavHost: transitions d'ecran desactivees (Enter/Exit None)
2026-09-24 20:32:08 +02:00
venture d1b0807d38 fix feedback bugs
CI / lint-backend (push) Successful in 1m27s
CI / lint-mobile (push) Successful in 10m24s
CI / test-backend (push) Successful in 1m33s
CI / test-mobile (push) Failing after 12m6s
CI / build-backend (push) Successful in 59s
CI / docker (push) Successful in 8s
2026-09-24 19:40:13 +02:00
venture 225f6e4b93 fix(ci): release Gitea idempotente (réutilise le tag existant, remplace l'APK)
Release / release-apk (push) Successful in 8m27s
Release / release-docker (push) Successful in 3m33s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m41s
CI / lint-mobile (push) Successful in 19m44s
CI / test-backend (push) Successful in 1m50s
CI / test-mobile (push) Successful in 8m27s
CI / build-backend (push) Successful in 45s
2026-09-24 06:43:59 +02:00
venture f97e0aed45 chore(deploy): release Gitea-only + compose prod (registre interne)
Release / release-apk (push) Failing after 6m37s
Release / release-docker (push) Successful in 7s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m18s
CI / lint-mobile (push) Successful in 8m14s
CI / test-backend (push) Successful in 1m21s
CI / test-mobile (push) Successful in 8m19s
CI / build-backend (push) Successful in 47s
2026-09-23 22:18:09 +02:00
venture 9dbd9d7a11 fix(ci): force bash shell in release workflow (pipefail under sh)
Release / release-apk (push) Successful in 8m27s
Release / release-docker (push) Failing after 10s
CI / docker (push) Successful in 6s
CI / lint-backend (push) Successful in 1m24s
CI / lint-mobile (push) Successful in 8m9s
CI / test-backend (push) Successful in 1m18s
CI / test-mobile (push) Successful in 8m17s
CI / build-backend (push) Successful in 43s
2026-09-23 19:37:36 +02:00
venture 33ff9a6789 add missing translation
CI / lint-backend (push) Successful in 1m21s
CI / lint-mobile (push) Successful in 8m14s
CI / test-backend (push) Successful in 1m20s
CI / test-mobile (push) Successful in 8m23s
Release / release-apk (push) Failing after 24s
Release / release-docker (push) Failing after 11s
CI / build-backend (push) Successful in 44s
CI / docker (push) Skipped
2026-09-23 10:32:15 +02:00
venture 22286aa2b1 fix mobile audit review: ownership, outbox purge, delete gates, journal-first sweep, parent link column
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Failing after 6m39s
CI / test-backend (push) Successful in 1m19s
CI / test-mobile (push) Successful in 8m18s
CI / build-backend (push) Successful in 43s
CI / docker (push) Successful in 8s
2026-09-23 00:25:27 +02:00
venture d89c0d03c9 fix 1 to 6 2026-09-22 23:55:49 +02:00
venture c642adb85b Replace docker image by ubuntu image
CI / lint-backend (push) Successful in 1m42s
CI / lint-mobile (push) Successful in 19m18s
CI / test-backend (push) Successful in 1m50s
CI / test-mobile (push) Successful in 8m21s
CI / build-backend (push) Successful in 43s
CI / docker (push) Successful in 3m25s
2026-09-22 06:50:04 +02:00
venture ed05093370 fix unused code
CI / lint-backend (push) Successful in 1m22s
CI / lint-mobile (push) Successful in 8m11s
CI / test-backend (push) Successful in 1m48s
CI / test-mobile (push) Successful in 8m15s
CI / build-backend (push) Successful in 43s
CI / docker (push) Failing after 31s
2026-09-21 20:20:15 +02:00
m 6b6f43bca9 fix ci: docker via socket hote (plus de dind), tags sha/latest, caches go/gradle, release apk durcie
CI / lint-backend (push) Failing after 1m19s
CI / lint-mobile (push) Canceled after 5m20s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-21 20:13:15 +02:00
m a6b7f2002b fix backend audit findings (auth, upload, sync, data, ocr, contract)
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-21 19:59:52 +02:00
m df7dc76405 fix build
CI / lint-backend (push) Successful in 1m17s
CI / lint-mobile (push) Successful in 8m35s
CI / test-backend (push) Successful in 1m19s
CI / test-mobile (push) Successful in 8m51s
CI / build-backend (push) Successful in 46s
CI / docker (push) Failing after 1m10s
2026-09-19 22:00:17 +02:00
m 409842694d fix fragile pipeline
CI / lint-backend (push) Successful in 1m20s
CI / lint-mobile (push) Canceled after 5m31s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-19 21:53:23 +02:00
m 33579a50a5 fix focker build
CI / lint-backend (push) Successful in 1m20s
CI / lint-mobile (push) Successful in 8m27s
CI / test-backend (push) Successful in 1m17s
CI / test-mobile (push) Successful in 8m31s
CI / build-backend (push) Successful in 44s
CI / docker (push) Failing after 9s
2026-09-19 21:01:00 +02:00
m 71c002b8b6 V4 to v3
CI / lint-backend (push) Successful in 1m20s
CI / lint-mobile (push) Successful in 8m21s
CI / test-backend (push) Successful in 1m18s
CI / test-mobile (push) Successful in 8m27s
CI / build-backend (push) Successful in 1m2s
CI / docker (push) Failing after 44s
2026-09-19 20:29:32 +02:00
m 5a452c46af fix migration test
CI / lint-backend (push) Successful in 1m22s
CI / lint-mobile (push) Successful in 8m21s
CI / test-backend (push) Successful in 1m16s
CI / test-mobile (push) Successful in 8m34s
CI / build-backend (push) Failing after 58s
CI / docker (push) Skipped
2026-09-19 20:05:08 +02:00
m d52460834a fix pipeline
CI / lint-backend (push) Successful in 2m33s
CI / lint-mobile (push) Successful in 8m29s
CI / test-backend (push) Failing after 1m10s
CI / build-backend (push) Skipped
CI / docker (push) Skipped
CI / test-mobile (push) Successful in 8m30s
2026-09-19 18:42:51 +02:00
m 901df79d86 fix pipeline version
CI / lint-backend (push) Failing after 41s
CI / lint-mobile (push) Failing after 46s
CI / test-backend (push) Failing after 42s
CI / build-backend (push) Skipped
CI / docker (push) Skipped
CI / test-mobile (push) Failing after 39s
2026-09-19 18:34:23 +02:00
m 7d67ce3681 modify image
CI / lint-backend (push) Failing after 4s
CI / lint-mobile (push) Failing after 3s
CI / test-backend (push) Failing after 3s
CI / build-backend (push) Skipped
CI / docker (push) Skipped
CI / test-mobile (push) Failing after 3s
2026-09-19 10:46:13 +02:00
m 65242ac3c7 modify ci to gitea
CI / lint-backend (push) Canceled after 0s
CI / lint-mobile (push) Canceled after 0s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-19 10:42:57 +02:00
m 318329a683 update signing properties + gitlab ci 2026-09-17 18:52:53 +02:00
m f29a3c3617 replace vault by kasier 2026-09-17 07:59:21 +02:00
m cd4f0179fc add gitlab ci 2026-09-16 14:47:10 +02:00
m 906d48702c ocr is working 2026-09-16 12:44:48 +02:00
m 050434325a add ocr pipeline 2026-09-15 23:52:19 +02:00
m 102cc425b9 ingore files 2026-09-15 23:51:24 +02:00
m 339d55d92f add version and translate all pages 2026-09-15 13:57:57 +02:00
m 4659f3abc5 display thumbnails 2026-09-15 10:28:03 +02:00
m 3499a3e356 display images thumbnail 2026-09-15 10:27:52 +02:00
m 194fd26693 scan document + creation de note 2026-09-15 09:09:49 +02:00
306 changed files with 23390 additions and 5618 deletions
+28
View File
@@ -0,0 +1,28 @@
# Production — copier vers .env.prod (jamais commité) et adapter.
# Utilisé avec : docker compose -f docker-compose.prod.yml --env-file .env.prod [pull|up -d]
# Image (registre Gitea). VERSION=latest par défaut ; pincer pour figer, ex. :
# VERSION=v0.1.0 (le tag release inclut le "v", cf. release.yml)
REGISTRY_IMAGE=gitea.thirdshop.fr/thirdshop/kazier
VERSION=latest
# Port d'écoute exposé sur l'hôte (derrière Caddy/Nginx/TLS en prod publique)
PORT=8080
# Postgres (mots de passe forts, générés, uniques à la prod)
POSTGRES_DB=kazier
POSTGRES_USER=kazier
POSTGRES_PASSWORD=CHANGE_ME_GENERER_UN_SECRET_LONG
# Backend
MAX_FILE_SIZE_MB=50
OCR_LANG=fra+eng
# Sécurité — générer un secret long et aléatoire, ex. :
# openssl rand -base64 48
AUTH_SECRET=CHANGE_ME_GENERER_UN_SECRET_LONG
# Premier admin (créé UNIQUEMENT si la table users est vide au premier boot).
# L'env n'écrase jamais un compte existant.
ADMIN_USERNAME=admin
ADMIN_PASSWORD=CHANGE_ME_MOT_DE_PASSE_INITIAL_FORT
+244
View File
@@ -0,0 +1,244 @@
# Pipeline Gitea Actions pour Kazier — lint + test + build + image registre.
#
# Prérequis act_runner (une seule fois) :
# - Runner act_runner enregistré contre l'instance Gitea, labels `ubuntu-24.04` dispo.
# - Job `docker` : s'exécute directement sur l'hôte du runner et utilise le
# daemon Docker local (pas de conteneur `docker:27`, pas de DinD,
# pas de `--privileged`, pas de montage `-v /var/run/docker.sock` : ce
# dernier faisait échouer la création du conteneur sous act_runner avec
# `Duplicate mount point: /var/run/docker.sock`, le runner injectant déjà
# ce mount). L'hôte doit donc avoir un daemon Docker sain + le CLI docker.
# - Gitea app.ini : [actions] ENABLED=true, DEFAULT_ACTIONS_URL=https://github.com
# - Droits d'écriture du runner sur son répertoire de travail/cache.
#
# Secrets (Settings > Actions) :
# - CONTAINER_REGISTRY_TOKEN PAT scope write:package (registre conteneur)
# - CONTAINER_REGISTRY_USER utilisateur propriétaire du PAT ci-dessus
name: CI
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
on:
push:
branches: [main]
tags: ["v*"]
pull_request:
permissions:
contents: read
env:
GO_VERSION: "1.26"
ANDROID_IMAGE: cimg/android:2024.01-node
CGO_ENABLED: "0"
# Registre conteneur Gitea (ex: cname de l'instance)
REGISTRY_HOST: gitea.thirdshop.fr
jobs:
lint-backend:
runs-on: ubuntu-24.04
container: golang:${{ env.GO_VERSION }}-alpine
steps:
# golang:alpine n'a ni node ni git — requis par les actions JS
# (checkout/cache) exécutées dans le container par act_runner.
- name: Install node + git (actions JS)
run: apk add --no-cache nodejs git
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- uses: actions/cache@v4
with:
path: |
/go/pkg/mod
~/.cache/go-build
key: go-${{ runner.os }}-${{ hashFiles('backend/go.mod', 'backend/go.sum') }}
restore-keys: |
go-${{ runner.os }}-
- run: go mod download
working-directory: backend
- run: go vet ./...
working-directory: backend
- run: go install honnef.co/go/tools/cmd/staticcheck@2026.2.1 && staticcheck ./...
working-directory: backend
lint-mobile:
runs-on: ubuntu-24.04
container: ${{ env.ANDROID_IMAGE }}
steps:
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- uses: actions/cache@v4
with:
path: |
~/.gradle/caches
~/.gradle/wrapper
key: gradle-${{ runner.os }}-${{ hashFiles('mobile-kotlin/gradle/libs.versions.toml', 'mobile-kotlin/gradle.properties', 'mobile-kotlin/settings.gradle.kts', 'mobile-kotlin/build.gradle.kts', 'mobile-kotlin/app/build.gradle.kts') }}
restore-keys: |
gradle-${{ runner.os }}-
- run: ./gradlew :app:lint -q
working-directory: mobile-kotlin
test-backend:
runs-on: ubuntu-24.04
container: golang:${{ env.GO_VERSION }}-alpine
services:
postgres:
image: postgres:17-alpine
env:
POSTGRES_DB: kazier_test
POSTGRES_USER: kazier
POSTGRES_PASSWORD: kazier
options: >-
--health-cmd "pg_isready -U kazier"
--health-interval 5s
--health-timeout 3s
--health-retries 10
steps:
- name: Install node + git (actions JS)
run: apk add --no-cache nodejs git
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- uses: actions/cache@v4
with:
path: |
/go/pkg/mod
~/.cache/go-build
key: go-${{ runner.os }}-${{ hashFiles('backend/go.mod', 'backend/go.sum') }}
restore-keys: |
go-${{ runner.os }}-
- run: |
set -euo pipefail
# dbtest fait un skip silencieux si Postgres est injoignable : on
# attend explicitement que le service accepte les connexions pour
# que le job échoue (pas skip) si PG ne monte jamais.
apk add --no-cache postgresql-client >/dev/null
for i in $(seq 1 30); do
if pg_isready -h postgres -U kazier -d kazier_test; then
exit 0
fi
sleep 1
done
echo "Postgres jamais prêt après 30s" >&2
exit 1
- run: go test ./...
working-directory: backend
env:
TEST_DATABASE_URL: postgres://kazier:kazier@postgres:5432/kazier_test?sslmode=disable
test-mobile:
runs-on: ubuntu-24.04
container: ${{ env.ANDROID_IMAGE }}
steps:
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- uses: actions/cache@v4
with:
path: |
~/.gradle/caches
~/.gradle/wrapper
key: gradle-${{ runner.os }}-${{ hashFiles('mobile-kotlin/gradle/libs.versions.toml', 'mobile-kotlin/gradle.properties', 'mobile-kotlin/settings.gradle.kts', 'mobile-kotlin/build.gradle.kts', 'mobile-kotlin/app/build.gradle.kts') }}
restore-keys: |
gradle-${{ runner.os }}-
- run: ./gradlew :app:testDebugUnitTest -q
working-directory: mobile-kotlin
build-backend:
runs-on: ubuntu-24.04
container: golang:${{ env.GO_VERSION }}-alpine
needs: [lint-backend, test-backend]
steps:
- name: Install node + git (actions JS)
run: apk add --no-cache nodejs git
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- run: |
set -euo pipefail
export VERSION="$(cat VERSION)"
CGO_ENABLED=0 GOOS=linux go build \
-trimpath \
-ldflags "-s -w -X main.version=${VERSION}" \
-o bin/kazier-server \
cmd/server/main.go
./bin/kazier-server --version
working-directory: backend
# v4 demande le service d'artefacts v2 (@actions/artifact v2) non fourni
# par Gitea (détecté comme GHES → GHESNotSupportedError). v3 reste le
# protocole legacy supporté par l'API artefacts de Gitea.
- uses: actions/upload-artifact@v3
with:
name: kazier-server
path: backend/bin/kazier-server
if-no-files-found: error
docker:
runs-on: ubuntu-24.04
# `build-backend` n'est qu'un garde-fou : le job docker ne télécharge pas
# son artifact, le Dockerfile recompile le binaire lui-même (build local
# autonome et reproductible). Le `needs` interdit juste de construire une
# image si lint + test + build échouent.
needs: [build-backend]
# Push branches uniquement : pas sur PR (pas de build d'image à la review),
# pas sur tag (c'est release.yml qui construit, évite une course dans le
# registre entre le job `docker` et `release-docker`).
if: github.event_name == 'push' && github.ref_type == 'branch'
# S'exécute directement sur l'hôte du runner (pas de `container: docker:27`) :
# le CLI docker de l'hôte parle au daemon local sans montage de socket.
# L'ancien montage explicite `-v /var/run/docker.sock:/var/run/docker.sock`
# via `container.options` faisait échouer la création du conteneur sous
# act_runner (`Duplicate mount point: /var/run/docker.sock` — le runner
# injecte déjà ce mount).
steps:
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- name: Sanity daemon Docker hôte
run: |
set -euo pipefail
docker info >/dev/null
echo "daemon Docker hôte joignable"
- name: Login registre Gitea
env:
CONTAINER_REGISTRY_TOKEN: ${{ secrets.CONTAINER_REGISTRY_TOKEN }}
CONTAINER_REGISTRY_USER: ${{ secrets.CONTAINER_REGISTRY_USER }}
run: |
set -euo pipefail
: "${CONTAINER_REGISTRY_TOKEN:?CONTAINER_REGISTRY_TOKEN manquant (PAT scope write:package)}"
: "${CONTAINER_REGISTRY_USER:?CONTAINER_REGISTRY_USER manquant (propriétaire du PAT)}"
echo "$CONTAINER_REGISTRY_TOKEN" | docker login "$REGISTRY_HOST" -u "$CONTAINER_REGISTRY_USER" --password-stdin
# Le registre impose un namespace minuscule (github.repository_owner
# peut être `Thirdshop` avec une majuscule → tag Docker invalide).
OWNER_LC="$(printf '%s' "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')"
echo "REGISTRY_IMAGE=${REGISTRY_HOST}/${OWNER_LC}/kazier" >> "$GITHUB_ENV"
echo "SHA_TAG=sha-$(printf '%s' "$GITHUB_SHA" | cut -c1-7)" >> "$GITHUB_ENV"
- name: Build + push (registre Gitea)
run: |
set -euo pipefail
# --pull : base alpine/golang fraîche ; --cache-from : réutilise les
# layers du dernier build `main` si dispo (build plus rapide).
docker pull "$REGISTRY_IMAGE:main" 2>/dev/null || true
docker build \
--pull \
--cache-from "$REGISTRY_IMAGE:main" \
--build-arg VERSION="$(cat VERSION)" \
--build-arg BUILD_DATE="$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-t "$REGISTRY_IMAGE:main" \
-t "$REGISTRY_IMAGE:$SHA_TAG" \
./backend
docker run --rm "$REGISTRY_IMAGE:$SHA_TAG" --version
docker push "$REGISTRY_IMAGE:main"
docker push "$REGISTRY_IMAGE:$SHA_TAG"
+165
View File
@@ -0,0 +1,165 @@
# Pipeline Gitea Actions pour Kazier — Release (tags vX.Y.Z uniquement).
#
# Construit l'APK signé (assembleRelease), crée la Release Gitea avec l'APK en
# asset (API, équivalent de `glab release create`), puis pousse l'image
# kazier-server sur le registre conteneur Gitea (tag + latest).
# Déploiement perso uniquement : pas de push Docker Hub.
#
# Prérequis act_runner : job `release-docker` s'exécute directement sur
# l'hôte et utilise le daemon Docker local (pas de conteneur `docker:27`,
# pas de DinD, pas de montage `-v /var/run/docker.sock` — ce dernier faisait
# échouer la création du conteneur sous act_runner avec
# `Duplicate mount point: /var/run/docker.sock`, le runner injectant déjà ce
# mount). L'hôte doit avoir un daemon Docker sain + le CLI docker.
#
# Secrets (Settings > Actions) :
# - RELEASE_KEYSTORE_B64 base64 du keystore release Android (jamais en clair)
# - SIGNING_STORE_PASSWORD SIGNING_KEY_ALIAS SIGNING_KEY_PASSWORD
# - RELEASE_API_TOKEN PAT scope write:repository (API : création Release)
# - CONTAINER_REGISTRY_TOKEN PAT scope write:package (registre conteneur Gitea)
# - CONTAINER_REGISTRY_USER utilisateur propriétaire du PAT ci-dessus
name: Release
on:
push:
tags: ["v*"]
permissions:
contents: read
env:
ANDROID_IMAGE: cimg/android:2024.01-node
# API Gitea (host de l'instance)
API_HOST: gitea.thirdshop.fr
jobs:
release-apk:
runs-on: ubuntu-24.04
container: ${{ env.ANDROID_IMAGE }}
steps:
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- uses: actions/cache@v4
with:
path: |
~/.gradle/caches
~/.gradle/wrapper
key: gradle-${{ runner.os }}-${{ hashFiles('mobile-kotlin/gradle/libs.versions.toml', 'mobile-kotlin/gradle.properties', 'mobile-kotlin/settings.gradle.kts', 'mobile-kotlin/build.gradle.kts', 'mobile-kotlin/app/build.gradle.kts') }}
restore-keys: |
gradle-${{ runner.os }}-
- name: Signer + assembler l'APK release
working-directory: mobile-kotlin
shell: bash
env:
RELEASE_KEYSTORE_B64: ${{ secrets.RELEASE_KEYSTORE_B64 }}
SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
run: |
set -euo pipefail
# Nettoie keystore + mots de passe même en cas d'échec du build.
cleanup() { rm -f app/release.keystore app/signing.properties; }
trap cleanup EXIT
if [ -z "${RELEASE_KEYSTORE_B64:-}" ]; then
echo "RELEASE_KEYSTORE_B64 manquant — release non signée." >&2
exit 1
fi
: "${SIGNING_STORE_PASSWORD:?SIGNING_STORE_PASSWORD manquant}"
: "${SIGNING_KEY_ALIAS:?SIGNING_KEY_ALIAS manquant}"
: "${SIGNING_KEY_PASSWORD:?SIGNING_KEY_PASSWORD manquant}"
echo "$RELEASE_KEYSTORE_B64" | base64 -d > app/release.keystore
cat > app/signing.properties <<EOF
storeFile=release.keystore
storePassword=${SIGNING_STORE_PASSWORD}
keyAlias=${SIGNING_KEY_ALIAS}
keyPassword=${SIGNING_KEY_PASSWORD}
EOF
./gradlew :app:assembleRelease -q
- name: Créer la Release Gitea + upload APK
shell: bash
env:
RELEASE_API_TOKEN: ${{ secrets.RELEASE_API_TOKEN }}
run: |
set -euo pipefail
VERSION="$(cat VERSION)"
TAG="v${VERSION}"
API="https://${API_HOST}/api/v1"
AUTH="Authorization: token ${RELEASE_API_TOKEN:?RELEASE_API_TOKEN manquant (PAT scope write:repository)}"
NOTES_JSON="$(python3 -c 'import json;print(json.dumps(open("CHANGELOG.md", encoding="utf-8").read()))')"
# Idempotent : si la release du tag existe déjà (re-tag, retry du job),
# la réutiliser au lieu d'échouer en 409.
if RELEASE_JSON="$(curl -sSf -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/tags/${TAG}" 2>/dev/null)"; then
echo "Release ${TAG} existante — réutilisation."
else
PAYLOAD_JSON="$(TAG="${TAG}" BODY="$NOTES_JSON" python3 -c 'import json,os;print(json.dumps({"tag_name":os.environ["TAG"],"name":"Kazier "+os.environ["TAG"],"body":json.loads(os.environ["BODY"])}))')"
RELEASE_JSON="$(curl -sSf -X POST "${API}/repos/${GITHUB_REPOSITORY}/releases" \
-H "${AUTH}" \
-H "Content-Type: application/json" \
-d "${PAYLOAD_JSON}")"
fi
RELEASE_ID="$(printf '%s' "${RELEASE_JSON}" | python3 -c 'import json,sys;print(json.load(sys.stdin)["id"])')"
: "${RELEASE_ID:?id de release introuvable dans la réponse API}"
# Asset idempotent : remplace l'APK existant de même nom s'il y en a un.
APK_PATH="mobile-kotlin/app/build/outputs/apk/release/app-release.apk"
EXISTING_ASSET_ID="$(curl -sSf -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets" \
| python3 -c 'import json,sys;assets=json.load(sys.stdin);print(next((str(a["id"]) for a in assets if a.get("name")=="app-release.apk"),""))')"
if [ -n "${EXISTING_ASSET_ID}" ]; then
echo "Asset existant ${EXISTING_ASSET_ID} — suppression avant re-upload."
curl -sSf -X DELETE -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets/${EXISTING_ASSET_ID}" > /dev/null
fi
curl -sSf -X POST \
"${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=app-release.apk" \
-H "${AUTH}" \
-F "attachment=@${APK_PATH}"
release-docker:
runs-on: ubuntu-24.04
# Directement sur l'hôte du runner (même raison que CI/docker : le montage
# explicite du socket via `container.options` doublonne celui injecté par
# act_runner → `Duplicate mount point`).
steps:
- uses: actions/checkout@v4
with:
token: ${{ secrets.GITEA_TOKEN }}
- name: Sanity daemon Docker hôte
shell: bash
run: |
set -euo pipefail
docker info >/dev/null
echo "daemon Docker hôte joignable"
- name: Login registre Gitea
shell: bash
env:
CONTAINER_REGISTRY_TOKEN: ${{ secrets.CONTAINER_REGISTRY_TOKEN }}
CONTAINER_REGISTRY_USER: ${{ secrets.CONTAINER_REGISTRY_USER }}
run: |
set -euo pipefail
: "${CONTAINER_REGISTRY_TOKEN:?CONTAINER_REGISTRY_TOKEN manquant (PAT scope write:package)}"
: "${CONTAINER_REGISTRY_USER:?CONTAINER_REGISTRY_USER manquant (propriétaire du PAT)}"
echo "$CONTAINER_REGISTRY_TOKEN" | docker login "$API_HOST" -u "$CONTAINER_REGISTRY_USER" --password-stdin
OWNER_LC="$(printf '%s' "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')"
echo "REGISTRY_IMAGE=${API_HOST}/${OWNER_LC}/kazier" >> "$GITHUB_ENV"
- name: "Build + push (registre Gitea : vX.Y.Z + latest)"
shell: bash
run: |
set -euo pipefail
VERSION="$(cat VERSION)"
docker pull "$REGISTRY_IMAGE:latest" 2>/dev/null || true
docker build \
--pull \
--cache-from "$REGISTRY_IMAGE:latest" \
--build-arg VERSION="${VERSION}" \
--build-arg BUILD_DATE="$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-t "$REGISTRY_IMAGE:v${VERSION}" \
-t "$REGISTRY_IMAGE:latest" \
./backend
docker run --rm "$REGISTRY_IMAGE:v${VERSION}" --version
docker push "$REGISTRY_IMAGE:v${VERSION}"
docker push "$REGISTRY_IMAGE:latest"
+30
View File
@@ -0,0 +1,30 @@
# Go backend
backend/bin/
backend/uploads/*
!backend/uploads/.gitkeep
# Env local (jamais commité — cf. backend/.env.example)
.env
backend/.env
# Uploads locaux transitoires (racine / backend)
uploads/
backend/uploads/*
# Android / Gradle
mobile-kotlin/local.properties
mobile-kotlin/.gradle/
mobile-kotlin/.kotlin/
**/build/
*.iml
.idea/
# Signature release Android (jamais commité)
signing.properties
*.jks
*.keystore
!signing.properties.example
# Artifacts
*.apk
dist/
+19 -17
View File
@@ -1,8 +1,8 @@
# VaultDrop # Kazier
## Project Status ## Project Status
`backend/` (Go) et `mobile-kotlin/` (Kotlin/Android) ont du scaffolding en place. Le client mobile est **local-first** : il reflète le SAF dans une base Room (v7, migrations, DAO) et pousse les **métadonnées** de ses mutations locales via un **outbox transactionnel** (`pending_operations` + worker WorkManager → `POST /sync/ops`). Pas d'upload physique, pas d'OCR ni de recherche serveur côté client en V1. `backend/` (Go) et `mobile-kotlin/` (Kotlin/Android) ont du scaffolding en place. Le client mobile est **local-first** : il reflète le SAF dans une base Room (v16, migrations, DAO) et pousse les **métadonnées** de ses mutations locales via un **outbox transactionnel** (`pending_operations` + worker WorkManager → `POST /sync/ops`). Upload physique ciblée (pipeline OCR : `POST /files/upload` + `resourceId`), streaming lecture des fichiers distants (`GET /files/:id/content`, jamais persisté), OCR serveur consommé côté client, recherche locale via Room (+ recherche serveur exposée mais non consommée).
## Architecture ## Architecture
@@ -38,11 +38,11 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- `config/` — env (`godotenv`, optionnel) + defaults: `PORT`, `DATABASE_URL`, `UPLOAD_DIR`, `MAX_FILE_SIZE_MB`, `OCR_LANG`, `AUTH_SECRET` (secret des tokens paseto), `ADMIN_USERNAME`/`ADMIN_PASSWORD` (bootstrap du premier admin) - `config/` — env (`godotenv`, optionnel) + defaults: `PORT`, `DATABASE_URL`, `UPLOAD_DIR`, `MAX_FILE_SIZE_MB`, `OCR_LANG`, `AUTH_SECRET` (secret des tokens paseto), `ADMIN_USERNAME`/`ADMIN_PASSWORD` (bootstrap du premier admin)
- `models/` — domain entities (users, devices, documents/resources, clients) - `models/` — domain entities (users, devices, documents/resources, clients)
- `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin) - `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin)
- `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs** — réels) ; middleware `RequireAuth` - `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs, files/:id/content, files/:id/shares, files/:id/links** — réels) ; middleware `RequireAuth`
- `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`) - `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot, `OpenContent` (bytes streaming), `ListShares`/`ListLinks` (owner-only) ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword ; `repository.Shares` : Upsert/Revoke, CreateLink/RevokeLink, ListActiveForResource, ListActiveLinksForResource, snapshot `ListEffectivePermissions`) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`)
- `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→000008) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down) - `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→000013) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down)
- `ocr/` — OCR engine behind an interface (Tesseract system call, `OCR_LANG` défaut `fra+eng`) - `ocr/` — OCR engine behind an interface (Tesseract system call, `OCR_LANG` défaut `fra+eng`)
- `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification bcrypt (timing-equal) - `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification argon2id (comparaison `subtle`, délai égalisé)
- File uploads stored in `backend/uploads/` - File uploads stored in `backend/uploads/`
- Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }` - Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }`
- Error format: `{ "error": { "code": "...", "message": "..." } }` - Error format: `{ "error": { "code": "...", "message": "..." } }`
@@ -50,41 +50,43 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
## Frontend Structure (mobile-kotlin) ## Frontend Structure (mobile-kotlin)
- Entry point: `app/src/main/java/com/vaultdrop/mobile/VaultDropApplication.kt` (Hilt + `HiltWorkerFactory`) + `MainActivity.kt` (Hilt) ; navigation Compose dans `ui/navigation/` (`NavGraph.kt`, `VaultDropApp.kt`) - Entry point: `app/src/main/java/com/kazier/mobile/KazierApplication.kt` (Hilt + `HiltWorkerFactory`) + `MainActivity.kt` (Hilt) ; navigation Compose dans `ui/navigation/` (`NavGraph.kt`, `KazierApp.kt`)
- Data layer — `data/`: - Data layer — `data/`:
- `data/local/` — Room SQLite (DB `dot.db`, **version 7**, `Migrations.kt` : tables `folders`, `files`, `user_preferences`, `pending_operations`) : entités Folder/File/UserPreference/PendingOperation, DAO, tri (`FileOrdering`) ; flag `processed` sur `files` (mode review « traiter », local au device, **gate de sync** : un fichier pas encore traité n'est jamais poussé) ; outbox transactionnel `pending_operations` (v7) - `data/local/` — Room SQLite (DB `dot.db`, **version 16**, `Migrations.kt` : tables `folders`, `files` (+ `category`, `processed`, `content`, `ocr_text`, `ocr_attempts`, `ocr_queued_at`), `user_preferences`, `pending_operations` (+ `device_id`, `parent_resource_id`), `scan_sessions`, `scan_pages`, `resource_permissions`) : entités + DAO, tri (`FileOrdering`), schéma exporté (`app/schemas/`, m19) ; flag `processed` sur `files` (mode review « traiter », local au device, **gate de sync** : un fichier pas encore traité n'est jamais poussé) ; outbox transactionnel `pending_operations`
- `data/remote/` — Retrofit/Moshi : `ApiService.kt` + `dto/Dtos.kt` = **contrat HTTP** (`{ data, meta }`, erreurs `{ error: { code, message } }`) ; `ApiClient.kt` normalise les réponses ; interceptors OkHttp (`AuthInterceptor`, `ServerUrlInterceptor`) - `data/remote/` — Retrofit/Moshi : `ApiService.kt` + `dto/Dtos.kt` = **contrat HTTP** (`{ data, meta }`, erreurs `{ error: { code, message } }`) ; `ApiClient.kt` normalise les réponses ; interceptors OkHttp (`AuthInterceptor`, `ServerUrlInterceptor`)
- `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource`/`move_resource`/`delete_resource`, écrivains dans la même transaction Room que la mutation parente ; pour un fichier SAF, la mutation parente du `create_resource` est le **garder** de la review (`markProcessed`), et `hasCreateOperation` en garde l'unicité) - `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource`/`move_resource`/`delete_resource` + ops partage `share`/`update_share`/`revoke_share`/`create_link`/`revoke_link`, écrivains dans la même transaction Room que la mutation parente ; pour un fichier SAF, la mutation parente du `create_resource` est le **garder** de la review (`markProcessed`), et `hasCreateOperation` en garde l'unicité), `ShareRepository` (hydratation + delta + `canAccess` depuis `GET /sync/permissions`), `OcrRepository` (upload ciblé + jobs + `syncFromServer`), `RemoteContentRepository` (streaming `GET /files/:id/content`, jamais persisté)
- `features/` — logique descendue côté client : - `features/` — logique descendue côté client :
- `sync/DeviceSync.kt` + `SafScanner.kt` — sync device↔SAF : **two-pass walk** (listing hors transaction puis upserts Room dans une seule transaction), réconciliation `exists = 0` (jamais de suppression), single-flight via `Mutex` ; les nouveaux **dossiers** sont journalisés dans l'outbox à la découverte, les **fichiers** uniquement au « garder » de la review (gate `processed`) - `sync/DeviceSync.kt` + `SafScanner.kt` — sync device↔SAF : **two-pass walk** (listing hors transaction puis upserts Room dans une seule transaction), réconciliation `exists = 0` (jamais de suppression), single-flight via `Mutex` ; les nouveaux **dossiers** sont journalisés dans l'outbox à la découverte, les **fichiers** uniquement au « garder » de la review (gate `processed`)
- `saf/` — `SafUris`, `SafFolderCreator`, `FileMover` (relocalisation SAF `DocumentsContract.moveDocument`, repli métadonnée seule ; le déplacement est poussé en `move_resource`), `SafFileDeleter` (suppression SAF + `delete_resource` atomique) - `saf/` — `SafUris`, `SafFolderCreator`, `FileMover` (relocalisation SAF `DocumentsContract.moveDocument`, repli métadonnée seule ; le déplacement est poussé en `move_resource`), `SafFileDeleter` (suppression SAF + `delete_resource` atomique)
- `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) - `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`)
- `sync/SyncViewModel.kt` — état du sync exposé à l'UI (`SyncStatus` : marche en cours, ops en attente, dernières opérations) via le badge header `ui/components/SyncStatusBadge.kt` + `SyncOperationsDialog.kt` (« liste des sync ») - `sync/SyncViewModel.kt` — état du sync exposé à l'UI (`SyncStatus` : marche en cours, ops en attente, dernières opérations) via le badge header `ui/components/SyncStatusBadge.kt` + `SyncOperationsDialog.kt` (« liste des sync »)
- `auth/` — session (login user + token paseto) : `SessionManager`, `SecureTokenStore`, `TokenProvider` - `auth/` — session (login user + token paseto + **re-login silencieux** sur 401 via identifiants chiffrés persistés, single-flight, événements `Reauthenticated`/`SessionExpired`) : `SessionManager`, `SecureTokenStore`, `TokenProvider`, `TokenStore` (+ `Credentials`)
- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte + placeholder cloud-only), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local), `components`, `theme` - `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien ; `OpenLinkScreen` + deep-link `kazier://share/<token>`), `components`, `theme`
- `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex) - `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex)
- `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`) - `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`)
- Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env) - Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env)
- Client **local-first** : lecture via `GET /files/folders`, `GET /files` ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource`) ; `POST /devices`, `POST /auth/login` ; download/upload physique hors scope - Client **local-first** : lecture via `GET /files/folders`, `GET /files` (+ streaming distant `GET /files/:id/content` pour les fichiers cloud-only, jamais persisté) ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource` + ops partage) ; `POST /devices`, `POST /auth/login` ; upload physique limité au pipeline OCR (`POST /files/upload` + `resourceId` ciblé)
## Data Conventions ## Data Conventions
- Canonical identity for folders/files is `resource_id`: opaque 32-hex, generated locally (`GenerateId`), never reused. The physical `uri` (SAF) is nullable (NULL = cloud-only) and is the reconciliation key for the SAF walk (unique index, NULLs distincts). - Canonical identity for folders/files is `resource_id`: opaque 32-hex, generated locally (`GenerateId`), never reused. The physical `uri` (SAF) is nullable (NULL = cloud-only) and is the reconciliation key for the SAF walk (unique index, NULLs distincts).
- Similarly, `pending_operations.operation_id` is a client-generated 32-hex (`GenerateId`), the idempotency key of the outbox `UNIQUE(device_id, operation_id)` lettre contre les rejeux du worker. - `pending_operations.operation_id` est un **TEXT 32-hex** généré par le client (`^[0-9a-f]{32}$`, CHECK-enforced côté serveur depuis la migration `000008`), distinct de `resource_id`. L'idempotence outbox reste **par device** : `UNIQUE(device_id, operation_id)` (colonne `device_id` côté mobile depuis Room v12).
- `owner_id` is **nullable** in the Room schema; it is set at runtime from `DeviceIdentity.getOrCreate()` during the SAF walk. - `owner_id` is **nullable** in the Room schema; it is set at runtime from `DeviceIdentity.getOrCreate()` during the SAF walk.
- Folder/file `sync_status` is a **placement** state: `local` | `cloud` | `local-cloud`. It is not a push progress marker. - Folder/file `sync_status` is a **placement** state: `local` | `cloud` | `local-cloud`. It is not a push progress marker.
- Client storage: `user_preferences` (clé/valeur) pour l'identité device, le compte actif, l'URL serveur, le thème, le mode local. - Client storage: `user_preferences` (clé/valeur) pour l'identité device, le compte actif, l'URL serveur, le thème, le mode local.
- Outbox atomique : `create_resource`/`move_resource`/`delete_resource` sont écrits dans la **même transaction Room** que la mutation parente ; l'écrivain (repository) et le worker partagent ce contrat. En mode local (pas de token), le worker est no-op. **Gate `processed`** : un fichier SAF nouvellement découvert est importé localement mais poussé seulement au « garder » (`markProcessed`, qui enqueue le `create_resource` dans la même transaction, une seule fois via `hasCreateOperation`) — d'où le filtrage des documents par l'utilisateur avant toute synchro. Un `delete_resource` n'est journalisé que si un `create_resource` a existé (jamais pour un fichier non poussé). - Outbox atomique : `create_resource`/`move_resource`/`delete_resource` sont écrits dans la **même transaction Room** que la mutation parente ; l'écrivain (repository) et le worker partagent ce contrat. En mode local (pas de token), le worker est no-op. **Gate `processed`** : un fichier SAF nouvellement découvert est importé localement mais poussé seulement au « garder » (`markProcessed`, qui enqueue le `create_resource` dans la même transaction, une seule fois via `hasCreateOperation`) — d'où le filtrage des documents par l'utilisateur avant toute synchro. Un `delete_resource` n'est journalisé que si un `create_resource` a existé (jamais pour un fichier non poussé).
- Pas de cache de permissions côté client en V1 : le serveur reste la source de vérité pour l'accès (`GET /sync/permissions` non consommé par le client Kotlin). - Cache de permissions côté client : `ShareRepository` hydrate `resource_permissions` depuis `GET /sync/permissions` (delta + pull complet, TTL 24h → downgrade lecture seule) et expose `canAccess` ; le serveur reste la source de vérité.
## API Contract (V1) ## API Contract (V1)
- **Le client mobile est le contrat**: les formes d'endpoints dans `mobile-kotlin/.../data/remote/ApiService.kt` + `dto/Dtos.kt` sont autoritatives et doivent matcher exactement ; le serveur ne renégocie pas. Spec consolidée: `docs/api-v1.md`. - **Le client mobile est le contrat**: les formes d'endpoints dans `mobile-kotlin/.../data/remote/ApiService.kt` + `dto/Dtos.kt` sont autoritatives et doivent matcher exactement ; le serveur ne renégocie pas. Spec consolidée: `docs/api-v1.md`.
- **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine. - **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine **silencieusement** via les identifiants chiffrés persistés (`SecureTokenStore`, single-flight, événements `Reauthenticated`/`SessionExpired`), sans rejouer la requête en vol.
- **Bootstrap**: au premier démarrage, si `users` est vide, `ADMIN_USERNAME`/`ADMIN_PASSWORD` (env) créent le premier admin ; absents → le serveur refuse de démarrer. L'env n'écrase jamais un compte existant. Usernames résolus sur `username_normalized` (lowercase + trim), `GET /users/resolve` exact uniquement (pas d'énumération). - **Bootstrap**: au premier démarrage, si `users` est vide, `ADMIN_USERNAME`/`ADMIN_PASSWORD` (env) créent le premier admin ; absents → le serveur refuse de démarrer. L'env n'écrase jamais un compte existant. Usernames résolus sur `username_normalized` (lowercase + trim), `GET /users/resolve` exact uniquement (pas d'énumération).
- **Identifiers**: `resource_id` / `device_user_id` / `user_id` / share-link `token` / `operation_id` sont des **lowercase 32-hex** TEXT (`^[0-9a-f]{32}$`, CHECK-enforced), stockés tels quels côté serveur (pas de conversion UUID). Le mobile génère toujours 32-hex. - **Identifiers**: `resource_id` / `device_user_id` / `user_id` / share-link `token` / `operation_id` sont des **lowercase 32-hex** TEXT (`^[0-9a-f]{32}$`, CHECK-enforced), stockés tels quels côté serveur (pas de conversion UUID). Le mobile génère toujours 32-hex.
- **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) — le walk SAF garantit parent avant enfant dans l'ordre d'`id`. - **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) — le walk SAF garantit parent avant enfant dans l'ordre d'`id`.
- **Permissions snapshot**: le serveur pousse des snapshots `resource_permissions` (`effective_access` ranking viewer < commenter < editor < owner, `inherit`, `expires_at`, TTL 24h → read-only downgrade). (Endpoint existant côté serveur ; pas encore consommé par le client Kotlin.) - **Permissions snapshot**: le serveur pousse des snapshots `resource_permissions` (`effective_access` ranking viewer < commenter < editor < owner, `inherit`, `expires_at`, TTL 24h → read-only downgrade). Consommé par le client Kotlin (`ShareRepository` : hydratation + delta + `canAccess`).
- **Lecture partagée** : `GET /files/:id/shares` + `GET /files/:id/links` (owner uniquement, 404 sinon) exposent grants et liens au propriétaire ; `GET /files/:id/content` streame les octets (viewer+, `Range` supporté).
## Non-Goals (V1) ## Non-Goals (V1)
@@ -92,7 +94,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- On-device OCR - On-device OCR
- Full multi-tenant federation / public discovery - Full multi-tenant federation / public discovery
- Multi-writer sync conflicts (single-owner device identity) - Multi-writer sync conflicts (single-owner device identity)
- Upload physique client→cloud (métadonnées seules via l'outbox, download, OCR jobs, permissions) côté mobile Kotlin - Upload physique généralisé client→cloud et download persistant (seuls l'upload ciblé OCR et le streaming lecture existent, cf. `docs/api-v1.md`)
## References ## References
+37
View File
@@ -0,0 +1,37 @@
# Changelog
Toutes les modifications notables de Kazier sont documentées ici.
Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le versioning est [SemVer](https://semver.org/lang/fr/).
## [Unreleased]
## [1.0.0] - 2026-09-25
### Ajouté
- Streaming lecture des fichiers distants : `GET /files/:id/content` (binaire brut, `Range`, viewer+), viewer mobile à la demande sans persistance (image/texte/PDF multi-pages, autres types non supportés).
- Gestion du partage côté owner : `GET /files/:id/shares` + `GET /files/:id/links`, sheet mobile (grants modifiables/révocables, liens création/copie/révocation, ouverture de lien, badge pending outbox), deep-link `kazier://share/<token>` + écran de résolution.
- Re-login silencieux : identifiants chiffrés persistés, renouvellement auto sur 401 (single-flight, file conservée si même compte), écran login avec avis d'expiration + username pré-rempli.
- Pipeline de release CI (GitLab) : lint, tests backend/mobile, build Docker, signature APK release, publication GitLab Release + Docker Hub.
- `backend/Dockerfile` multi-stage : image de production avec Tesseract (fra+eng) embarqué, user non-root, labels OCI.
- Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé).
- Signature release Android (`signing.properties` non commité, `assembleRelease`).
- Scripts `mise build:release`, `mise docker:build`, `mise release`.
- Licence AGPLv3, badge README, `CHANGELOG.md`.
- Versioning Android aligné sur le `VERSION` racine (versionCode dérivé).
### Changé
- **Renommage : VaultDrop → Kazier.** Marque, package Android (`com.kazier.mobile`), module Go (`github.com/kazier/backend`), binaire/image `kazier-server`, creds Postgres par défaut. Le code interne `dot.db` est conservé.
### Corrigé
- Docs : en-tête `docs/api-v1.md` (référence à l'ancien client Expo remplacée par le client Kotlin), quickstart et docker de la doc Starlight.
- `.gitignore` racine (uploads, binaires, keystore, artifacts).
## [0.1.0] - 2026-09-15
Première version publique.
### Ajouté
- Backend Go/Gin : auth user-first (paseto v4-local), devices, users (resolve, change password), CRUD fichiers/dossiers, upload multipart, recherche, sharing, sync outbox idempotente + snapshot permissions, OCR jobs (Tesseract), migrations Postgres testées.
- Client Android Kotlin : local-first Room (v7, migrations, DAO), SAF scanner deux passes, outbox transactionnel + worker WorkManager, recherche locale, génération PDF, scanner de documents, thumbnails, mode sombre, i18n FR/EN.
- Contrat API V1 consolidé (`docs/api-v1.md`), test de contrat de routes.
- Site de promotion public + documentation Starlight/Astro (FR/EN, versionnée).
+158
View File
@@ -0,0 +1,158 @@
# FEEDBACK — Audit bugs mobile-kotlin (local-first)
> Généré le 2026-09-22 par 5 agents d'exploration parallèles (scopes : Room/DB, sync/outbox/SAF, réseau/auth/repos, UI/navigation/VM, scan/pdf/review/thumbnails).
> Mise à jour le 2026-09-24 : les items corrigés par `d89c0d0 (fix 1 to 6)` et `22286aa (fix mobile audit review)` ont été re-vérifiés code en main et retirés. Ce document ne liste que le **reliquat confirmé**.
> Màj 2026-09-24 (soir) : tout le reliquat ci-dessous est **corrigé et testé** (`:app:testDebugUnitTest` : 162/162 verts, DB v16, schéma `app/schemas/16.json` exporté). Les sections 🟠/🟡/🛠️ sont conservées comme traçabilité.
> Chaque finding restant est vérifié avec preuve `file:line`.
> Scope : `mobile-kotlin/` uniquement.
> Légende : 🟠 Majeur (divergence silencieuse, contrat violé) · 🟡 Mineur (UX, perf, dette).
Base paths : `mobile-kotlin/app/src/main/java/com/kazier/mobile/…`
---
## ✅ Corrigés et retirés (vérifiés le 2026-09-24)
### 🔴 Critiques : 9/9 corrigés
- **C1** `domain/GenerateId.kt:19` — masque `and 0xFF` contre la sign-extension, 32-hex conforme.
- **C2** `features/sync/OutboxSyncWorker.kt:139-145` — erreurs non-attribuables (`INVALID_RESPONSE`, 429/408, 4xx batch-level) → `Result.retry()` sans toucher aux ops.
- **C3** `data/local/dao/PendingOperationDao.kt:66-72` — `purgeSynced` exclut les `create_resource` (tombstones), gates `countCreateOperations` préservés.
- **C4** `features/saf/FileDeleter.kt:122-128` + `FolderDeleter.kt:122-124` — journal-first (`withTransaction` avant suppression SAF) + `sweepPendingPhysicalDeletes`.
- **C5** `auth/SessionManager.kt:70-77` — `clear()` purge les ops non poussées (`pending`/`failed`), appelé par `AuthViewModel.signOut/signOutToLocal`.
- **C6** `OutboxSyncWorker.kt:185-188` — stop au 1er échec (`return success()`, jamais `continue`) + cascade transitive `cascadeCreateFailure` via `parent_resource_id`/payload.
- **C7** `OutboxSyncWorker.kt:152,170-174,193-196` — `applied.coerceIn`, `failedIndex < 0 → stop`, `applied == 0 → stop` (anti busy-loop/crash).
- **C8** Scan export — `ScanExport.pendingForExport` idempotent, `shouldFinishSession` gate `DONE`, `uniquePageFile()` UUID, `deletePage` DB-d'abord, `exportPdf` ne marque que les succès.
- **C9** `features/scan/ScanImageProcessor.kt:91-92` + `ScanViewModel.kt:213` — jamais de `recycle()` sur l'alias affiché (`!==` check).
### 🟠 Majeurs corrigés (31)
M1 (garde pending-move dossiers), M2 (gate `create` avant `move`), M3 (`FileMover` sans repli mensonger), M4 (exclusion `exists=0` pending seul), M6 (parent inconnu → `continue`), M7 (`importRoot` schedule le drain), M8 (fichiers 0-octet acceptés), M10 (`DeviceIdentity` mutex + `insertIgnore`), M11 (décision assumée : pas de backfill `create_resource`), M12 (`upsertTolerant` sur `resource_id`/`uri`), M14 (colonne `device_id`, `UNIQUE(device_id, operation_id)` + migration 11→12), M15 (`failDescendants` élargi, cf. C6), M21 (boucle `listFilesPaged` + `meta.total`), M22 (`ApiClient` distingue `CancellationException`/`JsonDataException`/`IOException`), M23 (`activeUserStore` vs `ownerId`, plus de confusion device/user), M24 (`normalizePayloadNumbers` Double→Long), M25 (`SessionManager` possède `onUnauthorized`), M26 (`ServerUrlInterceptor` `runBlocking load()` anti-race), M28 (validation URL `toHttpUrl()`), M29 (`pendingDefaultPick` saveable), M30 (pager `rememberSaveable`), M31 (debounce sur résultats seuls), M32 (gate `canShare` FolderDetail), M33 (`refreshShareGate` au login/logout), M34 (`selection.clear()` + chips figés en sélection), M35 (`resolveViewerPage` clamp), M36 (sélecteur thème 3 états), M37 (flag `dirty` anti-écrasement saisie), M38 (`MAX(sortOrder)+1`), M42 (`processed=true` PDF builder), M43 (réinsertion optimiste review), M44 (`remember(existingIds)` stable).
### 🟡 Mineurs corrigés dans `d89c0d0` (voir `git show --stat d89c0d0`)
m4 (gardes cursor SAF), m6 (`deleteLocally` transactionnel), m8 (`FileOrdering` aligné SQL), m9 (commentaire `attempts` diagnostic), m10-m14 (`updateUri`, `LocalModeStore`, `load` réarmable, `StateFlow` après succès DB, clé `SYNC_MODE` retirée), m16-m18 (index, `defaultValue processed`, `swapOrder` contraint), m22 (`ApiService` endpoints contrat ajoutés), m23 (`registerDevice` erreurs visibles), m24 (garde mode local), m25 (logging sans PII), m26 (`Bearer` hors routes publiques), m27 (`expiresAt` persisté), m28 (`SecureTokenStore` lazy + Direct Boot), m29-m31 (nav `pdfbuilder/empty`, `launchSingleTop`, controller hoisté), m33-m39 (side-effects `buildPhase`, dialogs `rememberSaveable`, badge collectes, saisie serveur debouncée, flash thème, bandeau import, `FileStatus.LOCAL`), m40-m56 (scan/camera/thumbnails : résolution bornée, `toBitmap` throttlé, listener retiré, `else` rotation, garde `sourceRect`, arrondi crop, `combine` nettoyé, purge `ABANDONED`, unicité session active, `FileCategory` CSV cohérent, purge map `Mutex`, `.tmp` nettoyés, `isUpToDate` taille+mtime, `runCatching` close, commentaire `max`, `release()` sur exception, deck conservé sur erreur).
---
## 🟠 Majeurs restants (4) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts)
- **M5 — `features/saf/FileDeleter.kt:88-104` + `features/saf/FolderDeleter.kt:91-103`** : `deleteInCloud` sans tombstone locale (`exists` reste 1) → ressource toujours affichée, walk la revoit, `refreshFromServer` ne supprime jamais de lignes → fantôme local vs serveur supprimé.
- **M9 — `features/saf/FolderMerger.kt:59,65-101`** : merge toujours multi-transactions (create, moves, deletes séparés) ; seule idempotence `findExistingMerged:154-161` ajoutée, pas d'atomicité → crash à mi-fusion = état partiel poussé.
- **M13 — entités `exists: Int? = null` + filtres `= 1`** (`FolderEntity.kt:36`, `FileEntity.kt:46`, `FolderDao.kt:43,50`, `FileDao.kt:27,44`) : toute ligne sans `exists` explicite disparaît UI/recherche/review — perte fonctionnelle silencieuse.
- **M27 — `data/repository/ShareRepository.kt:47` + `data/remote/dto/Dtos.kt:150-151`** : snapshot permissions sans delta (`after` jamais passé), `sharedById`/`expiresAt` en `Any?` jamais lus, `cachedAt` jamais persisté, aucun downgrade 24h ni `canAccess` → grant révoqué/expiré reste visible et ouvrable (`404`) jusqu'au prochain login.
---
## 🟡 Mineurs restants (8) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts)
### Sync / Worker / SAF
- **m1 — `features/sync/SyncViewModel.kt:108-133`** : `_walkInProgress` sans `finally` dans la boucle (reste `true` si scope annulé ; seul `importRoot:173` a un `finally`) → badge « syncing » collé ; la fenêtre inclut l'appel réseau partage.
- **m2 — `features/sync/SyncViewModel.kt:110-116`** : `OutboxSyncWorker.enqueue` + `OcrAutoWorker.enqueue` à chaque tick même sans changement → réveils WorkManager / 30s pour rien.
- **m5 — `features/sync/DeviceSync.kt:76-162`** : « transaction courte » en réalité géante (N upserts + `getAll()` dossiers **et** fichiers par racine sous verrou écriture) → lecteurs Room bloqués, jank/ANR sur grosses arborescences.
### Room / Domain / DI
- **m7 — `data/local/dao/FileDao.kt:45`** : `searchWithFilters` `LIKE` brut sans `ESCAPE`, casse ASCII-only → `%`/`_` = jokers (match-all), « ete » ne trouve pas « ÉTÉ ».
- **m15 — `di/DatabaseModule.kt:25-28`** : aucune stratégie de downgrade → APK plus ancien sur DB v14 = crash `IllegalStateException` au lieu de dégradation contrôlée.
- **m19 — `data/local/AppDatabase.kt:36-37`** : `version=14, exportSchema=false`, migrations non snapshotées → dérives indétectables en CI.
### Sync contrat / OCR
- **m20 — `data/repository/OcrRepository.kt:66-73`** : `poll()` infini (`while(true)` + 3s, sans timeout) alors qu'un job peut rester `processing` longtemps (stale claim serveur) → coroutine tenue indéfiniment.
- **m21 — `data/repository/OutboxRepository.kt:72-147`** : ops contrat non émissibles (`update_metadata`, `update_share`, `create_link`, `revoke_link` — §6.1 = 9 ops, helpers partiels) → rename partagé, update share, liens publics inopérants.
---
## 🛠️ Plans de correction (reliquat) — ✅ implémentés le 2026-09-24
Ordre suivi : M13 → M5 → M27+m21 → M9 → mineurs par lot (m1+m2, m5, m7, m20, m15+m19).
Écarts d'implémentation vs plan : M13 sans rewrite (colonne restée nullable, défaut Kotlin 1 + backfill — pas de bump de contrainte) ; m7 `COLLATE NOCASE` sans colonne normalisée (repli Unicode « ete » → « ÉTÉ » toujours ouvert, voir suivi) ; M27 `cachedAt` persisté = heure locale du pull (pas l'horloge serveur, skew).
### M5 — `deleteInCloud` sans tombstone locale
Fichiers : `features/saf/FileDeleter.kt:88-104`, `features/saf/FolderDeleter.kt:91-103` (+ descendants via `collectDescendants`).
Constat : `deleteInCloud` enqueue `delete_resource` mais laisse `exists = 1` ; la ressource reste affichée et le walk la revoit.
Plan :
1. Dans `FileDeleter.deleteInCloud`, après `enqueueDeleteResource`, appeler `fileRepository.markMissing(resourceId, now)` dans la même transaction Room (ou `appDatabase.withTransaction` comme `deleteFull`).
2. Dans `FolderDeleter.deleteInCloud`, idem pour le dossier ET sa descendance Room (`treeMarkMissing`-léger : `markMissing` sur fichiers + sous-dossiers, sans `delete_resource` supplémentaire sauf si `hasSyncedCreateOperation`).
3. Vérifier que le walk ne ressuscite pas : les lignes `exists = 0` + `delete_resource` pending doivent être ignorées par la réconciliation (garde `hasPendingDeleteOperation`, cf. `OutboxRepository.kt:204`).
4. UI : vérifier que les listes filtrent `exists = 1` (déjà le cas) → la ligne disparaît aussitôt.
Tests : étendre `ProcessedGateTest` ou nouveau `DeleteInCloudTest` — `deleteInCloud` puis assert `exists == 0` + op `delete_resource` présente ; walk simulé ne ressuscite pas.
### M9 — `FolderMerger` multi-transactions non-atomique
Fichier : `features/saf/FolderMerger.kt:53-106`.
Constat : `createMergedFolder` (transaction 1), moves (N transactions via `FileMover`/`reparentSubFolders`), deletes (N transactions). Un crash à mi-fusion laisse un état partiel ; la relance est idempotente (dossier réutilisé) mais ne reprend pas les moves manquants proprement.
Plan :
1. Envelopper `mergeSelectedFolders` dans `appDatabase.withTransaction` pour la partie Room (create + reparent + `treeMarkMissing`) — nécessite d'injecter `AppDatabase` dans `FolderMerger` et de rendre `FileMover.moveFiles` / `reparentSubFolders` appelables dans une transaction existante (ou journaliser les `move_resource`/`delete_resource` dans la transaction et n'exécuter le SAF physique qu'avant/après selon le sens crash-safe : journal-first comme C4).
2. Ordre crash-safe : (a) transaction Room = create + moves logiques + deletes logiques (`exists = 0` + outbox), (b) exécution SAF physique (moves + deletes), (c) sweep au prochain tick pour les physiques manqués (réutiliser `sweepPendingPhysicalDeletes`).
3. Garder l'idempotence `findExistingMerged` pour les relances.
4. À défaut d'une transaction unique (SAF non transactionnel), a minima : rendre chaque étape reprise-safe (skip les sources déjà vides, skip les moves déjà journalisés via `hasPendingMoveOperation`).
Tests : nouveau `FolderMergerTest` — fusion 2 dossiers avec fichiers + sous-dossier, assert `movedFiles/deletedFolders`, relance idempotente (pas de doublon), crash simulé entre étape 2 et 3 → reprise sans perte.
### M13 — `exists: Int? = null` invisible
Fichiers : `data/local/entity/FolderEntity.kt:36`, `data/local/entity/FileEntity.kt:46`, DAO (`FolderDao`, `FileDao` filtres `= 1`), `Migrations.kt` (créations tables sans `DEFAULT 1` / `NOT NULL`).
Constat : toute ligne insérée sans `exists` explicite (défaut Kotlin `null`) est cachée par les requêtes `WHERE exists = 1`.
Plan :
1. Durcir les entités : `exists: Int = 1` (non-null, défaut 1) dans `FolderEntity` et `FileEntity`.
2. Migration v14→v15 : `UPDATE folders SET exists = 1 WHERE exists IS NULL`, idem `files`, puis recréation ou `NOT NULL DEFAULT 1` (Room : via `autoMigrations` ou SQL `ALTER` + table rewrite selon la version SQLite ; le plus simple : `UPDATE` + contrainte applicative + défaut entité, sans rewrite si Room accepte le changement nullable→non-null via migration manuelle avec recréation de table).
3. Auditer tous les `saveFolder`/`saveLocalFile`/`upsertShared*` pour passer `exists = 1` explicitement.
4. Option : ajouter un test `ExistsDefaultTest` — insert sans `exists`, assert visible dans `observeByFolder`/`searchWithFilters`.
Note : migration à tester via `Migration13To14Test`-style (nouveau `Migration14To15Test`) + `:app:testDebugUnitTest`.
### M27 — snapshot permissions sans delta ni `canAccess`
Fichiers : `data/repository/ShareRepository.kt:44-47`, `data/remote/dto/Dtos.kt:144-156` (`sharedById`/`expiresAt: Any?`), `data/remote/ApiService.kt:74-78`, `ApiClient.kt:106-108`.
Constat : `syncPermissions()` sans `after`, champs `sharedById`/`expiresAt` jamais lus, `cachedAt` jamais persisté, aucun downgrade TTL 24h ni `canAccess` → grants révoqués/expirés visibles jusqu'au prochain login.
Plan :
1. DTO : typer `sharedById: String?`, `expiresAt: Long?` (le serveur renvoie ms epoch ou null — vérifier `docs/api-v1.md §6.2` et adapter avec un adapter Moshi tolérant `Any?`→Long).
2. Persistance : stocker `cachedAt`/`expiresAt`/`sharedById`/`effectiveAccess` — soit colonnes sur `files`/`folders`, soit nouvelle table `resource_permissions` (préférable : ne pas polluer les entités). A minima `user_preferences` : `permissions_cached_at`.
3. Delta : `syncSnapshot(after: Long? = cachedAt)` → `apiClient.syncPermissions(after)` ; pull complet (`after = null`) au login/restauration + quand `now - cachedAt > 24h` (TTL).
4. Expiration locale : au tick, marquer `exists = 0` les lignes dont `expiresAt < now` ; downgrade lecture seule après TTL sans reseed (gate `canAccess` : à exposer via `ShareRepository.canAccess(resourceId, required)` utilisé par les VM avant open/share/rename).
5. `canAccess` : ranking viewer < commenter < editor < owner, `ownerId == currentUser` → owner.
Tests : étendre `ShareRepositoryTest` — delta `after`, révocation (absent du snapshot → `markMissing`), expiration (`expiresAt` passé → masqué), `canAccess` ranking.
### m1+m2 — badge sync et réveils WorkManager
Fichier : `features/sync/SyncViewModel.kt:100-137`.
Plan :
1. m1 : envelopper le corps de boucle dans `try { … } finally { _walkInProgress.value = false }` (comme `importRoot:173-176`), et sortir `syncSnapshot` de la fenêtre `_walkInProgress` (flag séparé ou `syncing` = walk || drain déjà calculé via WorkManager).
2. m2 : n'enqueuer `OutboxSyncWorker`/`OcrAutoWorker` que si le tick a produit quelque chose (`results.any { folders+files+missing > 0 }` ou `pendingOperationDao.countPending() > 0` / fichier promu). Éviter les réveils /30s à vide.
Tests : Robolectric `SyncViewModelTest` — annulation du scope → flag retombe ; tick sans changement → `WorkManager` non sollicité (mock/static ou extraction d'un `SyncScheduler` testable).
### m5 — walk : transaction géante + `getAll()` par racine
Fichier : `features/sync/DeviceSync.kt:67-163`.
Plan :
1. Découper la phase 2 : upserts dossiers/fichiers par batch (ex. 200) en transactions courtes successives au lieu d'une transaction unique ; la réconciliation `missing` en passe séparée.
2. Remplacer `folderRepository.getAll()` + `fileRepository.getAll()` (full-table scan par racine) par des requêtes scopées à la racine (`getByRootUri`/`getDescendants`) — à ajouter aux DAO avec index sur `uri` (déjà unique) ; filtrer en SQL plutôt qu'en mémoire (`isChildOf` en `LIKE rootUri || '/%'`).
3. Conserver le `Mutex` single-flight ; vérifier `ensureActive()` dans les boucles longues pour annulation propre.
Tests : `SafScannerTest`-style perf — 5k fichiers simulés, assert temps/absence d'ANR ; test de convergence identique avant/après.
### m7 — recherche `LIKE` sans `ESCAPE`
Fichier : `data/local/dao/FileDao.kt:42-49`.
Plan : échapper `%`, `_`, `\` dans `:query` côté repository (`searchFiles`) + `LIKE … ESCAPE '\'` dans la requête ; ajouter `COLLATE NOCASE` (ou normalisation) pour « ete » → « ÉTÉ ». Tester : `%`, `_`, `\`, accents, casse.
Tests : `SearchFieldTest` ou nouveau `SearchEscapeTest` — `%` littéral ne matche pas tout, `_` littéral, insensible à la casse.
### m20 — `OcrRepository.poll()` infini
Fichier : `data/repository/OcrRepository.kt:66-73`.
Plan : ajouter timeout (ex. 10 min) + nombre max de polls + backoff ; lever `OcrTimeoutException` ou retourner le dernier état ; coopérer avec l'annulation (`ensureActive`). Mettre à jour les appelants (viewer auto) pour afficher « OCR indisponible, réessayer ».
Tests : `OcrRepositoryTest` — job restant `processing` → timeout au bout de N polls (fake `ApiClient` + virtual time/delays courts).
### m15+m19 — robustesse DB (downgrade + `exportSchema`)
Fichiers : `di/DatabaseModule.kt:25-28`, `data/local/AppDatabase.kt:31-38`.
Plan :
1. m19 : `exportSchema = true` + `schemas/` commité ; ajouter un test `Migration13To14Test`-style qui échoue en cas de dérive (CI).
2. m15 : stratégie downgrade explicite et documentée — soit `fallbackToDestructiveMigrationOnDowngrade()` (avec avertissement perte de données locales, acceptable car miroir SAF + outbox non poussée à préserver → plutôt refuser le démarrage avec message), soit crash contrôlé avec écran « mettez à jour l'app ». Choisir et documenter ; ne jamais laisser `IllegalStateException` brut.
Tests : build avec `exportSchema=true` + `room.schemaLocation` ; test downgrade (ouverture v15 avec APK v14 → comportement attendu).
### m21 — ops contrat non émissibles
Fichiers : `data/repository/OutboxRepository.kt:72-147`, `data/local/entity/PendingOperationEntity.kt:76-86` (constantes déjà présentes : `UPDATE_METADATA`, `UPDATE_SHARE`, `CREATE_LINK`, `REVOKE_LINK`).
Plan : ajouter `enqueueUpdateMetadata(resourceId, resourceType, name?)`, `enqueueUpdateShare(...)`, `enqueueCreateLink(resourceId, resourceType, token, access, expiresAt?)`, `enqueueRevokeLink(...)` avec payloads §6.1 (`granteeUserId/access/inherit/expiresAt`, `token/access/expiresAt`) ; brancher les appelants (rename partagé, update share, liens publics) ; `GenerateId` pour `token` 32-hex côté client.
Tests : `OutboxSyncWorkerTest`-style — sérialisation payload, `normalizePayloadNumbers` (`expiresAt` Long exact, non `1.7E12`), round-trip `POST /sync/ops` mocké.
---
## ✅ Vérifié infondé (suspects écartés)
- Single-flight `Mutex` présent (`DeviceSync.kt:49`), `enqueueUniqueWork(KEEP)` + batch 20 + `ORDER BY id` conformes — non-bugs.
- `checkHealth` construit bien `{base}/health` avec base incluant `/api/v1` = route backend `GET /api/v1/health` — OK.
- Token **non** stocké en clair (`EncryptedSharedPreferences` AES256-SIV/GCM + Keystore) — seul `TokenProvider.current` en mémoire, normal.
- Ordre interceptors `serverUrl → auth → logging`, `BASIC` ne log ni headers ni bodies — OK.
- Contrat HTTP conforme sur endpoints déclarés (query `folderId/page/pageSize`, `deviceId` camel vs `device_id` login, multipart `file`/`resourceId`/`folderId`, enveloppes `{data,meta}`/`{error:{code,message}}`, codes) — OK.
- `device_id` claim jamais utilisé comme preuve, seul le `Bearer` parle — conforme middleware.
- Worker no-op en mode local (`OutboxSyncWorker.kt:111`), batch 20 ≤ 100 serveur, statuts OCR, `resolveUser` trim compatible, password jamais trimé — OK.
- Deep-links : aucun défini (absence, pas de bug) ; args nav `folderResourceId`/`documentResourceId`/`ids` cohérents, 32-hex sans `/`.
- Hilt : `MainActivity @AndroidEntryPoint`, tous `hiltViewModel()` ↔ `@HiltViewModel`, scopes corrects — aucune injection manquante.
- Pas de recomposition infinie trouvée ; `collectAsStateWithLifecycle` partout ; placeholder cloud-only correct (`DocumentContentViewer.kt:39-47`) ; recherche 100 % locale conforme V1 ; back stack onglets correct (`saveState`/`restoreState`) ; `SelectionState` volatile documenté volontaire.
- Scan : pas de double-`recycle` draft, pas de double rotation EXIF (comportement correct, commentaire trompeur), `swapOrder` args corrects, FK `scan_pages→sessions CASCADE` actif.
+655
View File
@@ -0,0 +1,655 @@
GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU Affero General Public License is a free, copyleft license for
software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
Developers that use our General Public Licenses protect your rights
with two steps: (1) assert copyright on the software, and (2) offer
you this License which gives you legal permission to copy, distribute
and/or modify the software.
A secondary benefit of defending all users' freedom is that
improvements made in alternate versions of the program, if they receive
widespread use, become available for other developers to incorporate.
Many developers of free software are heartened and encouraged by the
resulting cooperation. However, in the case of software used on
network servers, this result may fail to come about. The GNU General
Public License permits making a modified version and letting the public
access it on a server without ever releasing its source code to the
public.
The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available
to the community. It requires the operator of a network server to
provide the source code of the modified version running there to the
users of that server. Therefore, public use of a modified version, on
a publicly accessible server, carries the obligation to make the source
code freely available.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU Affero General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms of
sections 4 and 5, provided that you also convey the machine-readable
Corresponding Source under the terms of this License, in one of these
ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions; the
above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that transaction
who receives a copy of the work also receives whatever licenses to the
work the party's predecessors in interest had or could give under the
previous paragraph, plus a right to possession of the Corresponding
Source of the work from the predecessor in interest, if the predecessor
has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the
Program, your modified version must prominently offer all users
interacting with it remotely through a computer network (if your version
supports such interaction) an opportunity to receive the Corresponding
Source of your version by providing access to the Corresponding Source
from a network server at no charge, through some standard or customary
means of facilitating copying of software. This Corresponding Source
shall include the Corresponding Source for any work covered by version 3
of the GNU General Public License that is incorporated pursuant to the
following paragraph.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the work with which it is combined will remain governed by version
3 of the GNU General Public License.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Affero General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU Affero
General Public License "or any later version" applies to it, you have
the option of following the terms and conditions either of that
numbered version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number
of the GNU Affero General Public License, you may choose any version
ever published by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU Affero General Public License can be used, that
proxy's public statement of acceptance of a version permanently
authorizes you to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Kazier — personal document vault, local-first.
Copyright (C) 2026 Thirdshop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If your software can interact with users remotely through a computer
network, you should also make sure that it provides a way for users to
get its source. For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code. There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for the
specific requirements.
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU AGPL, see
<https://www.gnu.org/licenses/>.
+6 -4
View File
@@ -1,8 +1,10 @@
# VaultDrop # Kazier
VaultDrop est un coffre-fort de documents personnel, local-first. Le client Android镜映 le SAF dans une base Room et pousse les métadonnées de ses mutations via un outbox transactionnel vers le serveur Go/PostgreSQL — pas d'upload physique, pas de cloud-dépendance. Kazier est un coffre-fort de documents personnel, local-first. Le client Android reflète le SAF dans une base Room et pousse les métadonnées de ses mutations via un outbox transactionnel vers le serveur Go/PostgreSQL — pas d'upload physique, pas de cloud-dépendance.
Disponible sur [thirdshop.fr](https://thirdshop.fr/en/applications/vault/) [![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](LICENSE)
Disponible sur [thirdshop.fr](https://thirdshop.fr/en/applications/kazier/)
## Setup ## Setup
@@ -27,5 +29,5 @@ cd mobile-kotlin && ./gradlew :app:testDebugUnitTest
| Backend entry | `backend/cmd/server/main.go` — wiring gin + routes | | Backend entry | `backend/cmd/server/main.go` — wiring gin + routes |
| Sync outbox | `mobile-kotlin/.../features/sync/OutboxSyncWorker.kt` — worker WorkManager → `POST /sync/ops` | | Sync outbox | `mobile-kotlin/.../features/sync/OutboxSyncWorker.kt` — worker WorkManager → `POST /sync/ops` |
| SAF scan | `mobile-kotlin/.../features/sync/DeviceSync.kt` — two-pass walk SAF ↔ Room | | SAF scan | `mobile-kotlin/.../features/sync/DeviceSync.kt` — two-pass walk SAF ↔ Room |
| Room DB | `mobile-kotlin/.../data/local/AppDatabase.kt` — version 7, migrations, DAO | | Room DB | `mobile-kotlin/.../data/local/AppDatabase.kt` — version 16, migrations, DAO |
| API Retrofit | `mobile-kotlin/.../data/remote/ApiService.kt` — interface Retrofit (contrat client) | | API Retrofit | `mobile-kotlin/.../data/remote/ApiService.kt` — interface Retrofit (contrat client) |
+1
View File
@@ -0,0 +1 @@
1.0.0
+8
View File
@@ -0,0 +1,8 @@
bin/
uploads/*
!uploads/.gitkeep
.env
.git
*.md
.vscode/
.idea/
+1 -1
View File
@@ -2,7 +2,7 @@
# Serveur # Serveur
PORT=8080 PORT=8080
DATABASE_URL=postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_dev?sslmode=disable DATABASE_URL=postgres://kazier:kazier@localhost:5432/kazier_dev?sslmode=disable
UPLOAD_DIR=./uploads UPLOAD_DIR=./uploads
MAX_FILE_SIZE_MB=50 MAX_FILE_SIZE_MB=50
OCR_LANG=fra+eng OCR_LANG=fra+eng
+59
View File
@@ -0,0 +1,59 @@
# syntax=docker/dockerfile:1
ARG VERSION=dev
ARG BUILD_DATE=unknown
# --- builder: compile statique du binaire Go (CGO off, musl) ---
FROM golang:1.26-alpine AS builder
ENV GOTOOLCHAIN=auto
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
ARG VERSION
RUN CGO_ENABLED=0 GOOS=linux go build \
-trimpath \
-ldflags "-s -w -X main.version=${VERSION}" \
-o /out/kazier-server \
./cmd/server/main.go
# --- runtime: mince, Tesseract (fra+eng) embarqué pour l'OCR ---
FROM alpine:3.20
RUN apk add --no-cache \
ca-certificates \
tzdata \
tesseract-ocr \
tesseract-ocr-data-eng \
tesseract-ocr-data-fra
WORKDIR /app
ARG VERSION
ARG BUILD_DATE
LABEL org.opencontainers.image.title="kazier-server" \
org.opencontainers.image.description="Kazier backend API (Go/Gin + PostgreSQL) — local-first document vault" \
org.opencontainers.image.version="${VERSION}" \
org.opencontainers.image.licenses="AGPL-3.0-only" \
org.opencontainers.image.source="https://gitea.thirdshop.fr/thirdshop/kazier" \
org.opencontainers.image.url="https://thirdshop.fr/en/applications/kazier/" \
org.opencontainers.image.created="${BUILD_DATE}" \
org.opencontainers.image.revision=""
COPY --from=builder /out/kazier-server /usr/local/bin/kazier-server
# UPLOAD_DIR persistant, user non-root
RUN mkdir -p /app/uploads \
&& adduser -D -H -u 10001 kazier \
&& chown kazier:kazier /app/uploads
VOLUME /app/uploads
ENV PORT=8080 \
UPLOAD_DIR=/app/uploads
USER kazier
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
CMD wget -q -O - http://127.0.0.1:8080/api/v1/health || exit 1
ENTRYPOINT ["kazier-server"]
+90 -16
View File
@@ -1,19 +1,29 @@
package main package main
import ( import (
"context"
"errors"
"fmt" "fmt"
"log" "log"
"net/http"
"os"
"os/signal"
"sync"
"syscall"
"time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/config" "github.com/kazier/backend/config"
"github.com/vaultdrop/backend/db" "github.com/kazier/backend/db"
"github.com/vaultdrop/backend/handlers" "github.com/kazier/backend/handlers"
"github.com/vaultdrop/backend/ocr" "github.com/kazier/backend/ocr"
"github.com/vaultdrop/backend/pkg/auth" "github.com/kazier/backend/pkg/auth"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
"github.com/vaultdrop/backend/service" "github.com/kazier/backend/service"
) )
var version = "dev"
func newRouter() *gin.Engine { func newRouter() *gin.Engine {
r := gin.Default() r := gin.Default()
handlers.RegisterRoutes(r) handlers.RegisterRoutes(r)
@@ -21,21 +31,30 @@ func newRouter() *gin.Engine {
} }
func main() { func main() {
if len(os.Args) > 1 && os.Args[1] == "--version" {
fmt.Printf("kazier-server %s\n", version)
os.Exit(0)
}
err, cfg := config.LoadApplicationConfig() cfg, err := config.LoadApplicationConfig()
if err != nil { if err != nil {
log.Fatalln(err) log.Fatalln(err)
} }
// Migrations AVANT l'ouverture du pool applicatif : un seul *sql.DB vit à
// la fois (MigrateDatabase ouvre/ferme sa propre connexion éphémère).
// Inter-lots : pour partager strictement le même pool, db doit exposer
// Migrate(conn *sql.DB) — fichier LOT 4 (db/db.go), non édité ici.
if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil {
log.Fatalf("migrations postgres: %v", err)
}
conn, err := db.Open(cfg.DatabaseURL) conn, err := db.Open(cfg.DatabaseURL)
if err != nil { if err != nil {
log.Fatalf("connexion postgres: %v", err) log.Fatalf("connexion postgres: %v", err)
} }
defer conn.Close()
if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil {
log.Fatalf("migrations postgres: %v", err)
}
authManager, err := auth.NewManager(cfg.AuthSecret) authManager, err := auth.NewManager(cfg.AuthSecret)
if err != nil { if err != nil {
@@ -46,8 +65,19 @@ func main() {
repo := repository.NewRepository(conn) repo := repository.NewRepository(conn)
// Premier admin (users vide) — refus de démarrer si identifiants absents. // Premier admin (users vide) — refus de démarrer si identifiants absents.
// Concurrence au boot (2 instances, users vide) : le perdant de l'INSERT
// reçoit ErrNameConflict (UNIQUE username_normalized) → recompte avant de
// refuser de démarrer (retry logique, sans toucher bootstrap.go — LOT 4).
if err := service.EnsureAdmin(repo, cfg.AdminUsername, cfg.AdminPassword); err != nil { if err := service.EnsureAdmin(repo, cfg.AdminUsername, cfg.AdminPassword); err != nil {
log.Fatalln(err) if errors.Is(err, repository.ErrNameConflict) {
if n, cerr := repo.Users.Count(); cerr == nil && n > 0 {
log.Println("bootstrap admin: compte créé par une instance concurrente, démarrage poursuivi")
} else {
log.Fatalln(err)
}
} else {
log.Fatalln(err)
}
} }
handlers.Store = service.NewResources( handlers.Store = service.NewResources(
@@ -57,8 +87,52 @@ func main() {
) )
handlers.Ocr = service.NewOcr(repo, cfg.UploadDir, cfg.OcrLang, ocr.NewTesseract()) handlers.Ocr = service.NewOcr(repo, cfg.UploadDir, cfg.OcrLang, ocr.NewTesseract())
if err := newRouter().Run(fmt.Sprintf(":%d", cfg.Port)); err != nil { ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
log.Fatalln(err) defer stop()
}
// Worker OCR borné (OCR_WORKERS) : file `ocr_jobs`, hors request handlers.
// WaitGroup + budget d'arrêt partagé (5s, voir shutdown plus bas) : le
// worker finit le job en cours ; passé le délai, le process sort et le job
// resté `processing` sera requeue au prochain boot (ResetStaleProcessing).
var ocrWg sync.WaitGroup
ocrWg.Add(1)
go func() {
defer ocrWg.Done()
handlers.Ocr.Run(ctx, cfg.OcrWorkers)
}()
log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers)
srv := &http.Server{
Addr: fmt.Sprintf(":%d", cfg.Port),
Handler: newRouter(),
}
go func() {
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("server: %v", err)
}
}()
<-ctx.Done()
stop()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("shutdown: %v", err)
}
// Le worker OCR dispose du même budget de 5s : on attend la fin du job en
// cours, passé ce délai le process sort (job resté `processing` → requeue
// au prochain boot via ResetStaleProcessing, jamais de job perdu).
ocrDone := make(chan struct{})
go func() {
ocrWg.Wait()
close(ocrDone)
}()
select {
case <-ocrDone:
log.Println("worker OCR arrêté")
case <-shutdownCtx.Done():
log.Println("worker OCR: budget 5s écoulé, arrêt forcé (jobs `processing` requeues au prochain boot)")
}
log.Println("arrêt propre")
} }
+9 -9
View File
@@ -4,19 +4,19 @@ import (
"fmt" "fmt"
"testing" "testing"
"github.com/vaultdrop/backend/models" "github.com/kazier/backend/models"
) )
func TestUserCreation(t *testing.T) { func TestUserCreation(t *testing.T) {
err, userAntoine := models.NewUser("antoine") userAntoine, err := models.NewUser("antoine")
if err != nil { if err != nil {
t.Errorf(`Error creating antoine user %v`, err) t.Fatalf("creating antoine user: %v", err)
} }
err, userBob := models.NewUser("bob") userBob, err := models.NewUser("bob")
if err != nil { if err != nil {
t.Errorf(`Error creating bob user %v`, err) t.Fatalf("creating bob user: %v", err)
} }
fmt.Println(userAntoine, userBob) fmt.Println(userAntoine, userBob)
@@ -25,14 +25,14 @@ func TestUserCreation(t *testing.T) {
func TestCreateDocument(t *testing.T) { func TestCreateDocument(t *testing.T) {
err, document := models.NewDocument("paper.pdf", models.FILE, 1) document, err := models.NewDocument("paper.pdf", models.FILE, 1)
if err != nil { if err != nil {
t.Errorf(`Error creating document %v`, err) t.Fatalf("creating document: %v", err)
} }
err, directory := models.NewDocument("bob", models.DIRECTORY, 1) directory, err := models.NewDocument("bob", models.DIRECTORY, 1)
if err != nil { if err != nil {
t.Errorf(`Error creating bob directory %v`, err) t.Fatalf("creating bob directory: %v", err)
} }
fmt.Println(document, directory) fmt.Println(document, directory)
+24 -2
View File
@@ -13,10 +13,14 @@ var expectedRoutes = []string{
"GET /api/v1/shares/links/:token", "GET /api/v1/shares/links/:token",
"GET /api/v1/files", "GET /api/v1/files",
"GET /api/v1/files/:id",
"DELETE /api/v1/files/:id",
"GET /api/v1/files/search", "GET /api/v1/files/search",
"GET /api/v1/files/folders", "GET /api/v1/files/folders",
"GET /api/v1/files/:id",
"GET /api/v1/files/:id/ocr",
"GET /api/v1/files/:id/content",
"GET /api/v1/files/:id/shares",
"GET /api/v1/files/:id/links",
"DELETE /api/v1/files/:id",
"POST /api/v1/files/upload", "POST /api/v1/files/upload",
"GET /api/v1/users/resolve", "GET /api/v1/users/resolve",
@@ -43,3 +47,21 @@ func TestRoutesMatchClientContract(t *testing.T) {
} }
} }
// TestStaticFileRoutesListedBeforeParam (LOT 6 §1) : verrouille que les routes
// statiques /files/search et /files/folders restent déclarées avant
// /files/:id dans le contrat. Gin priorise déjà le statique sur le paramétré
// à l'exécution, mais l'ordre source documente l'intention ("/files/folders
// ne doit jamais être avalé par FilesGet avec id="folders"). Le comportement
// réel est couvert côté handlers (folders→200, :id="folders"→404).
func TestStaticFileRoutesListedBeforeParam(t *testing.T) {
index := map[string]int{}
for i, r := range expectedRoutes {
index[r] = i
}
for _, static := range []string{"GET /api/v1/files/search", "GET /api/v1/files/folders"} {
if index[static] > index["GET /api/v1/files/:id"] {
t.Errorf("contrat: %q doit rester listé avant %q (ordre §1)", static, "GET /api/v1/files/:id")
}
}
}
+56 -7
View File
@@ -1,8 +1,10 @@
package config package config
import ( import (
"fmt"
"os" "os"
"strconv" "strconv"
"strings"
"github.com/joho/godotenv" "github.com/joho/godotenv"
) )
@@ -13,39 +15,86 @@ type ApplicationConfig struct {
UploadDir string UploadDir string
MaxFileSizeMB int64 MaxFileSizeMB int64
OcrLang string OcrLang string
OcrWorkers int
AuthSecret string AuthSecret string
AdminUsername string AdminUsername string
AdminPassword string AdminPassword string
} }
func LoadApplicationConfig() (error, *ApplicationConfig) { // Sécurité AUTH_SECRET (FEEDBACK #4) :
// - valeur par défaut DEV UNIQUEMENT (jamais en production : refusée au boot
// si APP_ENV/ENV vaut "prod"/"production") ;
// - longueur minimale 32 caractères partout (dev comme prod) : le secret ne
// sert qu'à dériver la clé paseto v4-local (SHA256), un secret court ou
// deviné = tokens forgeables.
//
// NOTE inter-lots (LOT 6 « secret-doc ») : aligner backend/.env.example —
// documenter « ≥ 32 caractères, ex. `openssl rand -hex 32` » et ne plus
// suggérer une valeur copiable telle quelle.
const (
defaultAuthSecret = "dev-secret-change-me-please-set-in-prod"
minAuthSecretLen = 32
)
func LoadApplicationConfig() (*ApplicationConfig, error) {
// .env optionnel — les défauts suffisent pour le dev local. // .env optionnel — les défauts suffisent pour le dev local.
_ = godotenv.Load() _ = godotenv.Load()
port, err := getInt("PORT", 8080) port, err := getInt("PORT", 8080)
if err != nil { if err != nil {
return err, nil return nil, err
}
if port < 1 || port > 65535 {
return nil, fmt.Errorf("PORT hors plage 1-65535: %d", port)
} }
maxSize, err := getInt("MAX_FILE_SIZE_MB", 50) maxSize, err := getInt("MAX_FILE_SIZE_MB", 50)
if err != nil { if err != nil {
return err, nil return nil, err
}
if maxSize < 1 || maxSize > 1024 {
return nil, fmt.Errorf("MAX_FILE_SIZE_MB hors plage 1-1024: %d", maxSize)
} }
return nil, &ApplicationConfig{ ocrWorkers, err := getInt("OCR_WORKERS", 2)
if err != nil {
return nil, err
}
if ocrWorkers < 1 || ocrWorkers > 16 {
return nil, fmt.Errorf("OCR_WORKERS hors plage 1-16: %d", ocrWorkers)
}
authSecret := get("AUTH_SECRET", defaultAuthSecret)
if isProduction() && (authSecret == "" || authSecret == defaultAuthSecret) {
return nil, fmt.Errorf("AUTH_SECRET doit être défini en production (pas de défaut)")
}
if len(authSecret) < minAuthSecretLen {
return nil, fmt.Errorf("AUTH_SECRET trop court (min %d caractères)", minAuthSecretLen)
}
return &ApplicationConfig{
Port: port, Port: port,
DatabaseURL: get("DATABASE_URL", "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_dev?sslmode=disable"), DatabaseURL: get("DATABASE_URL", "postgres://kazier:kazier@localhost:5432/kazier_dev?sslmode=disable"),
UploadDir: get("UPLOAD_DIR", "./uploads"), UploadDir: get("UPLOAD_DIR", "./uploads"),
MaxFileSizeMB: int64(maxSize), MaxFileSizeMB: int64(maxSize),
OcrLang: get("OCR_LANG", "fra+eng"), OcrLang: get("OCR_LANG", "fra+eng"),
AuthSecret: get("AUTH_SECRET", "dev-secret-change-me"), OcrWorkers: ocrWorkers,
AuthSecret: authSecret,
AdminUsername: get("ADMIN_USERNAME", ""), AdminUsername: get("ADMIN_USERNAME", ""),
AdminPassword: get("ADMIN_PASSWORD", ""), AdminPassword: get("ADMIN_PASSWORD", ""),
} }, nil
} }
func isProduction() bool {
env := strings.ToLower(strings.TrimSpace(os.Getenv("APP_ENV")))
if env == "" {
env = strings.ToLower(strings.TrimSpace(os.Getenv("ENV")))
}
return env == "production" || env == "prod"
}
func get(name string, defaultValue string) string { func get(name string, defaultValue string) string {
value := os.Getenv(name) value := os.Getenv(name)
if value == "" { if value == "" {
+51 -9
View File
@@ -9,7 +9,8 @@ func clearEnv(t *testing.T) {
t.Helper() t.Helper()
for _, name := range []string{ for _, name := range []string{
"PORT", "DATABASE_URL", "UPLOAD_DIR", "MAX_FILE_SIZE_MB", "PORT", "DATABASE_URL", "UPLOAD_DIR", "MAX_FILE_SIZE_MB",
"OCR_LANG", "AUTH_SECRET", "ADMIN_USERNAME", "ADMIN_PASSWORD", "OCR_LANG", "OCR_WORKERS", "AUTH_SECRET", "ADMIN_USERNAME", "ADMIN_PASSWORD",
"APP_ENV", "ENV",
} { } {
t.Setenv(name, "") t.Setenv(name, "")
} }
@@ -18,7 +19,7 @@ func clearEnv(t *testing.T) {
func TestLoadApplicationDefaults(t *testing.T) { func TestLoadApplicationDefaults(t *testing.T) {
clearEnv(t) clearEnv(t)
err, cfg := LoadApplicationConfig() cfg, err := LoadApplicationConfig()
if err != nil { if err != nil {
t.Fatalf("LoadApplicationConfig: %v", err) t.Fatalf("LoadApplicationConfig: %v", err)
} }
@@ -28,7 +29,7 @@ func TestLoadApplicationDefaults(t *testing.T) {
if cfg.MaxFileSizeMB != 50 { if cfg.MaxFileSizeMB != 50 {
t.Errorf("MaxFileSizeMB = %d, attendu 50", cfg.MaxFileSizeMB) t.Errorf("MaxFileSizeMB = %d, attendu 50", cfg.MaxFileSizeMB)
} }
if cfg.DatabaseURL != "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_dev?sslmode=disable" { if cfg.DatabaseURL != "postgres://kazier:kazier@localhost:5432/kazier_dev?sslmode=disable" {
t.Errorf("DatabaseURL défaut inattendu: %q", cfg.DatabaseURL) t.Errorf("DatabaseURL défaut inattendu: %q", cfg.DatabaseURL)
} }
if cfg.UploadDir != "./uploads" { if cfg.UploadDir != "./uploads" {
@@ -37,9 +38,15 @@ func TestLoadApplicationDefaults(t *testing.T) {
if cfg.OcrLang != "fra+eng" { if cfg.OcrLang != "fra+eng" {
t.Errorf("OcrLang défaut inattendu: %q", cfg.OcrLang) t.Errorf("OcrLang défaut inattendu: %q", cfg.OcrLang)
} }
if cfg.AuthSecret != "dev-secret-change-me" { if cfg.OcrWorkers != 2 {
t.Errorf("OcrWorkers = %d, attendu 2", cfg.OcrWorkers)
}
if cfg.AuthSecret != defaultAuthSecret {
t.Errorf("AuthSecret défaut inattendu: %q", cfg.AuthSecret) t.Errorf("AuthSecret défaut inattendu: %q", cfg.AuthSecret)
} }
if len(cfg.AuthSecret) < minAuthSecretLen {
t.Errorf("AuthSecret défaut trop court pour le minimum %d: %q", minAuthSecretLen, cfg.AuthSecret)
}
if cfg.AdminUsername != "" || cfg.AdminPassword != "" { if cfg.AdminUsername != "" || cfg.AdminPassword != "" {
t.Errorf("identifiants admin doivent être vides par défaut: %+v", cfg) t.Errorf("identifiants admin doivent être vides par défaut: %+v", cfg)
} }
@@ -52,32 +59,67 @@ func TestLoadApplicationEnvOverrides(t *testing.T) {
t.Setenv("DATABASE_URL", "postgres://u:p@host:5433/db?sslmode=disable") t.Setenv("DATABASE_URL", "postgres://u:p@host:5433/db?sslmode=disable")
t.Setenv("UPLOAD_DIR", "/tmp/up") t.Setenv("UPLOAD_DIR", "/tmp/up")
t.Setenv("OCR_LANG", "eng") t.Setenv("OCR_LANG", "eng")
t.Setenv("AUTH_SECRET", "super-secret") t.Setenv("OCR_WORKERS", "4")
t.Setenv("AUTH_SECRET", "super-secret-0123456789abcdef01234567")
t.Setenv("ADMIN_USERNAME", "root") t.Setenv("ADMIN_USERNAME", "root")
t.Setenv("ADMIN_PASSWORD", "toor") t.Setenv("ADMIN_PASSWORD", "toor")
err, cfg := LoadApplicationConfig() cfg, err := LoadApplicationConfig()
if err != nil { if err != nil {
t.Fatalf("LoadApplicationConfig: %v", err) t.Fatalf("LoadApplicationConfig: %v", err)
} }
if cfg.Port != 9090 || cfg.MaxFileSizeMB != 120 || cfg.DatabaseURL != "postgres://u:p@host:5433/db?sslmode=disable" || if cfg.Port != 9090 || cfg.MaxFileSizeMB != 120 || cfg.DatabaseURL != "postgres://u:p@host:5433/db?sslmode=disable" ||
cfg.UploadDir != "/tmp/up" || cfg.OcrLang != "eng" || cfg.AuthSecret != "super-secret" || cfg.UploadDir != "/tmp/up" || cfg.OcrLang != "eng" || cfg.OcrWorkers != 4 || cfg.AuthSecret != "super-secret-0123456789abcdef01234567" ||
cfg.AdminUsername != "root" || cfg.AdminPassword != "toor" { cfg.AdminUsername != "root" || cfg.AdminPassword != "toor" {
t.Errorf("overrides non appliqués: %+v", cfg) t.Errorf("overrides non appliqués: %+v", cfg)
} }
} }
func TestLoadApplicationRejectsShortSecret(t *testing.T) {
clearEnv(t)
t.Setenv("AUTH_SECRET", "too-short")
if _, err := LoadApplicationConfig(); err == nil {
t.Error("AUTH_SECRET court : attendu une erreur (min 32)")
}
// Le défaut dev passe en dev mais est refusé en production.
clearEnv(t)
if _, err := LoadApplicationConfig(); err != nil {
t.Errorf("défaut dev en dev : inattendu %v", err)
}
for _, env := range []string{"prod", "production", "PROD"} {
clearEnv(t)
t.Setenv("APP_ENV", env)
if _, err := LoadApplicationConfig(); err == nil {
t.Errorf("défaut dev avec APP_ENV=%q : attendu une erreur", env)
}
clearEnv(t)
t.Setenv("ENV", env)
if _, err := LoadApplicationConfig(); err == nil {
t.Errorf("défaut dev avec ENV=%q : attendu une erreur", env)
}
}
// Un secret long et explicite passe en production.
clearEnv(t)
t.Setenv("APP_ENV", "prod")
t.Setenv("AUTH_SECRET", "prod-secret-0123456789abcdef01234567")
if _, err := LoadApplicationConfig(); err != nil {
t.Errorf("secret prod valide : inattendu %v", err)
}
}
func TestLoadApplicationRejectsInvalidInt(t *testing.T) { func TestLoadApplicationRejectsInvalidInt(t *testing.T) {
clearEnv(t) clearEnv(t)
t.Setenv("PORT", "not-a-number") t.Setenv("PORT", "not-a-number")
if err, _ := LoadApplicationConfig(); err == nil { if _, err := LoadApplicationConfig(); err == nil {
t.Error("PORT invalide : attendu une erreur") t.Error("PORT invalide : attendu une erreur")
} }
clearEnv(t) clearEnv(t)
t.Setenv("MAX_FILE_SIZE_MB", "99999999999999999999999") t.Setenv("MAX_FILE_SIZE_MB", "99999999999999999999999")
if err, _ := LoadApplicationConfig(); err == nil { if _, err := LoadApplicationConfig(); err == nil {
t.Error("MAX_FILE_SIZE_MB invalide : attendu une erreur") t.Error("MAX_FILE_SIZE_MB invalide : attendu une erreur")
} }
} }
@@ -1,9 +1,21 @@
-- Reverse de 000007. Réversible SEULEMENT sur base vide (les ressources sont -- Reverse de 000007. Chemin TESTS uniquement : ne jamais down en production
-- détruites dans les deux sens : sans device associé, il n'y a rien à -- avec des données.
-- préserver). -- Les ressources retrouvent leur device d'origine via devices.user_id
DELETE FROM resources; -- (premier device trouvé en cas de multi-device — mapping non bijectif
-- assumé) ; les orphelines (user_id NULL, ou user sans device, ou valeur ne
-- correspondant à aucun device) sont détruites car owner_id est NOT NULL
-- avec FK vers devices.
UPDATE resources r
SET user_id = d.device_id
FROM devices d
WHERE d.user_id = r.user_id;
DELETE FROM resources
WHERE user_id IS NULL
OR user_id NOT IN (SELECT device_id FROM devices);
ALTER TABLE resources DROP CONSTRAINT resources_user_id_fkey; ALTER TABLE resources DROP CONSTRAINT resources_user_id_fkey;
ALTER TABLE resources RENAME COLUMN user_id TO owner_id; ALTER TABLE resources RENAME COLUMN user_id TO owner_id;
ALTER TABLE resources ALTER COLUMN owner_id SET NOT NULL;
ALTER TABLE resources ADD CONSTRAINT resources_owner_id_fkey ALTER TABLE resources ADD CONSTRAINT resources_owner_id_fkey
FOREIGN KEY (owner_id) REFERENCES devices(device_id) ON DELETE CASCADE; FOREIGN KEY (owner_id) REFERENCES devices(device_id) ON DELETE CASCADE;
@@ -1,15 +1,35 @@
-- Bascule ownership device → user (étapes 6-10 de la tranche identité). -- Bascule ownership device → user (étapes 6-10 de la tranche identité).
-- Destructif ASSUMÉ : à ce stade aucune release V1, la base de dev est RESET -- Migration DOUCE et non destructive (cf. #10) : AUCUNE suppression de
-- (DELETE trivial sur une table vide ; PAS de user marqueur). Le modele -- ressources (l'ancien DELETE FROM resources est supprimé).
-- resources reste parfaitement identique par ailleurs. -- Le device d'origine est résolu vers son dernier utilisateur connu
DELETE FROM resources; -- (devices.user_id) ; les ressources orphelines (device sans user connu ou
-- device inconnu) gardent user_id NULL — visibles par personne mais
-- conservées — et user_id reste donc NULLABLE après cette migration.
ALTER TABLE resources DROP CONSTRAINT resources_owner_id_fkey; ALTER TABLE resources DROP CONSTRAINT resources_owner_id_fkey;
ALTER TABLE resources RENAME COLUMN owner_id TO user_id; ALTER TABLE resources RENAME COLUMN owner_id TO user_id;
-- La colonne hérite du NOT NULL de owner_id : on l'assouplit AVANT le
-- backfill pour accueillir les orphelines.
ALTER TABLE resources ALTER COLUMN user_id DROP NOT NULL;
-- Backfill : device → dernier utilisateur connu.
UPDATE resources r
SET user_id = d.user_id
FROM devices d
WHERE r.user_id = d.device_id
AND d.user_id IS NOT NULL;
-- Orphelines : tout ce qui ne référence toujours pas un user existant → NULL.
UPDATE resources
SET user_id = NULL
WHERE user_id IS NOT NULL
AND user_id NOT IN (SELECT id FROM users);
ALTER TABLE resources ADD CONSTRAINT resources_user_id_fkey ALTER TABLE resources ADD CONSTRAINT resources_user_id_fkey
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE; FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
-- Les index créés en 000003 (idx_resources_owner, idx_resources_root_name -- Les index créés en 000003 (idx_resources_owner, idx_resources_root_name
-- sur owner_id) suivent le renommage Intrinsèquement : ils portent désormais -- sur owner_id) suivent le renommage intrinsèquement : ils portent désormais
-- sur user_id. L'unicité racine devient donc « 1 nom par USER » (multi-device -- sur user_id. L'unicité racine devient donc « 1 nom par USER » (multi-device
-- possible pour le même compte). -- possible pour le même compte).
@@ -1,4 +1,23 @@
-- Down de 000008 : retour operation_id TEXT 32-hex → BIGINT.
-- PERTES ASSUMÉES, chemin TESTS uniquement (migrate down complet) : seules
-- les valeurs exclusivement numériques sur ≤ 18 chiffres significatifs
-- (traces héritées paddées par le up, p.ex. '0000…0042' → 42) survivent ;
-- les vrais 32-hex client-generated (contenant a-f, ou > 18 chiffres pour
-- éviter tout overflow bigint) ne sont pas convertibles et leurs lignes
-- sont supprimées. L'ancien `USING operation_id::bigint` échouait sur ces
-- valeurs. Ne jamais down en production avec des données V1 : recréer la
-- base plutôt que `migrate down`.
ALTER TABLE operations DROP CONSTRAINT operations_operation_id_hex_check; ALTER TABLE operations DROP CONSTRAINT operations_operation_id_hex_check;
ALTER TABLE operations ALTER TABLE operations ADD COLUMN operation_id_bigint BIGINT;
ALTER COLUMN operation_id TYPE BIGINT USING operation_id::bigint;
UPDATE operations
SET operation_id_bigint = operation_id::bigint
WHERE operation_id ~ '^0*[0-9]{1,18}$';
DELETE FROM operations WHERE operation_id_bigint IS NULL;
ALTER TABLE operations DROP COLUMN operation_id;
ALTER TABLE operations RENAME COLUMN operation_id_bigint TO operation_id;
ALTER TABLE operations ALTER COLUMN operation_id SET NOT NULL;
ALTER TABLE operations ADD CONSTRAINT operations_unique_per_device UNIQUE (device_id, operation_id);
@@ -0,0 +1 @@
ALTER TABLE resources DROP COLUMN ocr_text;
@@ -0,0 +1,5 @@
-- Texte OCR porté sur la ressource (docs/api-v1.md §5) : le worker OCR écrit
-- l'extrait (`resources.ocr_text`, updated_at bumpé) pour qu'il soit
-- consultable par tous les devices du user ET par les grantees
-- (GET /files/:id/ocr, visibilité viewer+).
ALTER TABLE resources ADD COLUMN ocr_text TEXT;
@@ -0,0 +1 @@
DROP INDEX IF EXISTS idx_resources_owner_updated_active;
@@ -0,0 +1,7 @@
-- LOT 4 (DATA ownership) : index snapshot delta — ListOwned filtre
-- (user_id, updated_at) WHERE deleted_at IS NULL. Numéro réservé au LOT 4
-- par le plan TASKS_PARALLELES.md (LOT 5 = 000012, LOT 3 = 000013) : cette
-- migration bouche aussi le trou de version (golang-migrate refuse les gaps
-- au `Up` une fois 000012/000013 présentes).
CREATE INDEX IF NOT EXISTS idx_resources_owner_updated_active
ON resources(user_id, updated_at) WHERE deleted_at IS NULL;
@@ -0,0 +1 @@
DROP INDEX IF EXISTS idx_ocr_jobs_status_created;
@@ -0,0 +1,4 @@
-- Index composite pour la file OCR : ClaimNext filtre `status = 'queued'` et
-- trie par `created_at, job_id` (FIFO). L'index simple (status) de 000005
-- est conservé (LOT 4 reste propriétaire du schéma historique).
CREATE INDEX IF NOT EXISTS idx_ocr_jobs_status_created ON ocr_jobs(status, created_at);
@@ -0,0 +1,2 @@
ALTER TABLE operations DROP CONSTRAINT IF EXISTS operations_payload_hash_hex_check;
ALTER TABLE operations DROP COLUMN IF EXISTS payload_hash;
@@ -0,0 +1,10 @@
-- Trace outbox : hash du payload (A9, LOT 3).
-- Au rejeu du même (device_id, operation_id) avec un payload différent, le
-- serveur rejette en INVALID_REQUEST au lieu d'un skip silencieux.
-- Colonne NULLABLE : les traces héritées (pré-000013) restent valides ; pour
-- elles, le hash est recalculé en Go depuis le payload stocké.
ALTER TABLE operations ADD COLUMN payload_hash TEXT;
ALTER TABLE operations
ADD CONSTRAINT operations_payload_hash_hex_check
CHECK (payload_hash IS NULL OR payload_hash ~ '^[0-9a-f]{64}$');
+69 -6
View File
@@ -2,20 +2,21 @@ package db
import ( import (
"database/sql" "database/sql"
"os" "fmt"
"net/url"
"strings" "strings"
"testing" "testing"
_ "github.com/lib/pq" "github.com/lib/pq"
) )
const defaultTestDatabaseURL = "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_migrations_test?sslmode=disable" const defaultTestDatabaseURL = "postgres://kazier:kazier@localhost:5432/kazier_migrations_test?sslmode=disable"
func testDatabaseURL(t *testing.T) string { func testDatabaseURL(t *testing.T) string {
t.Helper() t.Helper()
url := os.Getenv("TEST_DATABASE_URL") url := TestDatabaseURL(defaultTestDatabaseURL)
if url == "" { if err := ensureTestDatabaseExists(url); err != nil {
url = defaultTestDatabaseURL t.Fatalf("ensure database: %v", err)
} }
conn, err := sql.Open("postgres", url) conn, err := sql.Open("postgres", url)
if err != nil { if err != nil {
@@ -28,6 +29,41 @@ func testDatabaseURL(t *testing.T) string {
return url return url
} }
// ensureTestDatabaseExists crée la base de tests du package quand Postgres est
// joignable mais que la base n'est pas encore provisionnée (service CI frais,
// volume local vierge). Le probing de disponibilité et le skip restent le rôle
// du Ping de testDatabaseURL.
func ensureTestDatabaseExists(databaseURL string) error {
parsed, err := url.Parse(databaseURL)
if err != nil {
return err
}
dbName := strings.TrimPrefix(parsed.Path, "/")
if dbName == "" {
return nil
}
maintenance := *parsed
maintenance.Path = "/postgres"
conn, err := sql.Open("postgres", maintenance.String())
if err != nil {
return err
}
defer conn.Close()
if err := conn.Ping(); err != nil {
return nil // Postgres down : le Ping du test skippera
}
var exists bool
if err := conn.QueryRow(`SELECT EXISTS(SELECT 1 FROM pg_database WHERE datname = $1)`, dbName).Scan(&exists); err != nil {
return err
}
if !exists {
if _, err := conn.Exec(fmt.Sprintf(`CREATE DATABASE %s`, pq.QuoteIdentifier(dbName))); err != nil {
return err
}
}
return nil
}
func resetSchema(t *testing.T, url string) { func resetSchema(t *testing.T, url string) {
t.Helper() t.Helper()
conn, err := sql.Open("postgres", url) conn, err := sql.Open("postgres", url)
@@ -179,6 +215,33 @@ func TestMigrationsUpDown(t *testing.T) {
t.Error("FK resources.user_id → users(id) manquante après 000007") t.Error("FK resources.user_id → users(id) manquante après 000007")
} }
// --- 000007 : migration douce (#10) ----------------------------------
// user_id NULLABLE (orphelines conservées, pas de DELETE FROM resources).
var userIDNullable string
err = conn.QueryRow(`
SELECT is_nullable FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'resources' AND column_name = 'user_id'`).Scan(&userIDNullable)
if err != nil {
t.Fatalf("resources.user_id nullabilité: %v", err)
}
if userIDNullable != "YES" {
t.Error("resources.user_id doit être NULLABLE après 000007 (migration douce, orphelines)")
}
// --- 000011 : index snapshot delta (LOT 4) -----------------------------
var ownerUpdatedIdx int
err = conn.QueryRow(`
SELECT COUNT(*) FROM pg_index i
JOIN pg_class t ON t.oid = i.indrelid
WHERE t.relname = 'resources' AND i.indisvalid
AND pg_get_indexdef(i.indexrelid) LIKE '%idx_resources_owner_updated_active%'`).Scan(&ownerUpdatedIdx)
if err != nil {
t.Fatalf("000011 index: %v", err)
}
if ownerUpdatedIdx == 0 {
t.Error("index idx_resources_owner_updated_active manquant après 000011")
}
// operation_id outbox = UUID 32-hex client-generated — cf. docs/api-v1.md §6.1 // operation_id outbox = UUID 32-hex client-generated — cf. docs/api-v1.md §6.1
var opType string var opType string
err = conn.QueryRow(` err = conn.QueryRow(`
+35
View File
@@ -0,0 +1,35 @@
package db
import (
"net/url"
"os"
)
// TestDatabaseURL resolve l'URL que chaque package de test doit utiliser pour
// joindre SA base dédiée.
//
// Chaque package possède une URL par défaut portant un nom de base distinct
// (kazier_repository_test, kazier_handlers_test, kazier_migrations_test…), de
// sorte que `go test ./...` puisse lancer les binaires de test en parallèle
// sans qu'ils ne s'écrasent le schéma. Quand TEST_DATABASE_URL est posée (CI),
// elle joue le rôle d'override d'endpoint : scheme, hôte, identifiants et
// paramètres de connexion gagnent, mais le nom de base du package est
// conservé. Sans variable d'env, l'URL par défaut du package est retournée
// telle quelle.
func TestDatabaseURL(packageURL string) string {
env := os.Getenv("TEST_DATABASE_URL")
if env == "" {
return packageURL
}
base, err := url.Parse(env)
if err != nil || base.Scheme == "" || base.Host == "" {
return packageURL
}
pkg, err := url.Parse(packageURL)
if err != nil || pkg.Path == "" || pkg.Path == "/" {
return env
}
merged := *base
merged.Path = pkg.Path
return merged.String()
}
+6 -10
View File
@@ -4,31 +4,27 @@ import (
"database/sql" "database/sql"
"fmt" "fmt"
"net/url" "net/url"
"os"
"strings" "strings"
"testing" "testing"
"github.com/lib/pq" "github.com/lib/pq"
"github.com/vaultdrop/backend/db" "github.com/kazier/backend/db"
) )
// OpenTestDatabase ensures the test database exists, resets its schema, runs // OpenTestDatabase ensures the test database exists, resets its schema, runs
// all migrations, and returns a live connection (closed via t.Cleanup). // all migrations, and returns a live connection (closed via t.Cleanup).
// Tests are skipped only when Postgres itself is unreachable. `databaseURL` // Tests are skipped only when Postgres itself is unreachable. `databaseURL`
// empty falls back to TEST_DATABASE_URL, then to the global default. // empty falls back to the global default. TEST_DATABASE_URL (CI) n'override
// que l'endpoint (hôte/creds) : le nom de base propre au package est
// préservé, pour que les packages parallèles ne partagent jamais un schéma.
func OpenTestDatabase(t *testing.T, databaseURL string) *sql.DB { func OpenTestDatabase(t *testing.T, databaseURL string) *sql.DB {
t.Helper() t.Helper()
switch {
case databaseURL == "":
databaseURL = os.Getenv("TEST_DATABASE_URL")
case os.Getenv("TEST_DATABASE_URL") != "":
databaseURL = os.Getenv("TEST_DATABASE_URL")
}
if databaseURL == "" { if databaseURL == "" {
databaseURL = "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_test?sslmode=disable" databaseURL = "postgres://kazier:kazier@localhost:5432/kazier_test?sslmode=disable"
} }
databaseURL = db.TestDatabaseURL(databaseURL)
// Postgres joignable ? (sinon on skippe, sans être gênés par l'existence // Postgres joignable ? (sinon on skippe, sans être gênés par l'existence
// ou non de la base cible) // ou non de la base cible)
+1 -1
View File
@@ -1,4 +1,4 @@
module github.com/vaultdrop/backend module github.com/kazier/backend
go 1.26.4 go 1.26.4
+83 -12
View File
@@ -4,15 +4,15 @@ import (
"errors" "errors"
"net/http" "net/http"
"strings" "strings"
"sync"
"time" "time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/vaultdrop/backend/pkg/auth" "github.com/kazier/backend/pkg/passwd"
"github.com/vaultdrop/backend/pkg/passwd" "github.com/kazier/backend/repository"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/service"
"github.com/vaultdrop/backend/service"
) )
type LoginRequest struct { type LoginRequest struct {
@@ -33,9 +33,55 @@ type LoginResponse struct {
User LoginUserDTO `json:"user"` User LoginUserDTO `json:"user"`
} }
// Anti-bruteforce du login (FEEDBACK #12) : limiteur basique en mémoire,
// N tentatives / minute / IP sur POST /auth/login, placé AVANT la vérification
// argon2 (coûteuse) pour protéger le CPU. Au-delà → 429 RATE_LIMITED.
// TODO(suivi) : rate-limit distribué (ex. Redis) + métriques pour les déploiements
// multi-réplicas, et budget global coordonné avec le rate-limit POST /devices
// (LOT 6) contre le remplissage de table.
var (
loginRateLimitPerMinute = 60
loginRateWindow = time.Minute
loginAttemptsMu sync.Mutex
loginAttempts = map[string][]time.Time{}
)
// OnLoginRateLimited est un hook d'observabilité appelé quand le limiteur
// rejette une tentative (nil par défaut = no-op). Les tests peuvent l'utiliser
// pour asserter le déclenchement sans dépendre du timing.
var OnLoginRateLimited func(ip string)
// ResetLoginRateLimit vide le compteur (tests uniquement).
func ResetLoginRateLimit() {
loginAttemptsMu.Lock()
defer loginAttemptsMu.Unlock()
loginAttempts = map[string][]time.Time{}
}
// loginRateLimited enregistre une tentative et retourne true si le quota
// IP est dépassé (fenêtre glissante).
func loginRateLimited(ip string, now time.Time) bool {
loginAttemptsMu.Lock()
defer loginAttemptsMu.Unlock()
cutoff := now.Add(-loginRateWindow)
kept := make([]time.Time, 0, len(loginAttempts[ip])+1)
for _, t := range loginAttempts[ip] {
if t.After(cutoff) {
kept = append(kept, t)
}
}
if len(kept) >= loginRateLimitPerMinute {
loginAttempts[ip] = kept
return true
}
loginAttempts[ip] = append(kept, now)
return false
}
// AuthLogin est la SEULE porte d'émission de token (V1). L'erreur est // AuthLogin est la SEULE porte d'émission de token (V1). L'erreur est
// volontairement indistinguable entre « username inconnu » et « mauvais mot de // volontairement indistinguable entre « username inconnu », « mauvais mot de
// passe » — même code, même message, délai égalisé via passwd.VerifyTimedEqual. // passe » et « device non enregistré » — même code 401, même message, délai
// égalisé via passwd.VerifyTimedEqual (anti-oracle, FEEDBACK #12).
func AuthLogin(c *gin.Context) { func AuthLogin(c *gin.Context) {
if Store == nil || Store.Repository == nil || Auth == nil { if Store == nil || Store.Repository == nil || Auth == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -51,12 +97,24 @@ func AuthLogin(c *gin.Context) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "username, password and device_id are required") api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "username, password and device_id are required")
return return
} }
if !deviceIDPattern.MatchString(req.DeviceID) {
api.Error(c, http.StatusBadRequest, "INVALID_DEVICE_ID", "device_id must be 32 lowercase hex chars")
return
}
if loginRateLimited(c.ClientIP(), time.Now()) {
if OnLoginRateLimited != nil {
OnLoginRateLimited(c.ClientIP())
}
api.Error(c, http.StatusTooManyRequests, "RATE_LIMITED", "too many login attempts, retry later")
return
}
normalized := service.NormalizeUsername(req.Username) normalized := service.NormalizeUsername(req.Username)
user, userErr := Store.Repository.Users.GetByUsernameNormalized(normalized) user, userErr := Store.Repository.Users.GetByUsernameNormalized(normalized)
// Même durée de traitement que le compte existe ou non (username inconnu => // Même durée de traitement que le compte existe ou non (username inconnu =>
// stored vide → vérification contre dummyHash). // stored vide → vérification contre dummyHash aléatoire par boot).
stored := "" stored := ""
if userErr == nil && user != nil { if userErr == nil && user != nil {
stored = user.PasswordHash stored = user.PasswordHash
@@ -69,6 +127,12 @@ func AuthLogin(c *gin.Context) {
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not verify credentials") api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not verify credentials")
return return
} }
// A1 : ne jamais déréférencer user si inconnu — même si Verify (par
// extraordinaire) réussissait, on reste en 401.
if userErr != nil || user == nil {
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
return
}
exists, err := Store.Repository.Devices.Exists(req.DeviceID) exists, err := Store.Repository.Devices.Exists(req.DeviceID)
if err != nil { if err != nil {
@@ -76,24 +140,31 @@ func AuthLogin(c *gin.Context) {
return return
} }
if !exists { if !exists {
api.Error(c, http.StatusBadRequest, "INVALID_DEVICE_ID", "device not registered") // Volontairement indistinguable d'un mauvais password (anti-oracle).
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
return return
} }
if err := Store.Repository.Devices.MarkUser(req.DeviceID, user.ID); err != nil { if err := Store.Repository.Devices.MarkUser(req.DeviceID, user.ID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
// Course : device supprimé entre Exists et MarkUser → même 401
// indistinguable, jamais de token pour un device fantôme.
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
return
}
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update device") api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update device")
return return
} }
token, err := Auth.Issue(user.ID, req.DeviceID) token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID)
if err != nil { if err != nil {
api.Error(c, http.StatusInternalServerError, "TOKEN_ERROR", "could not issue token") api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token")
return return
} }
api.OK(c, LoginResponse{ api.OK(c, LoginResponse{
Token: token, Token: token,
ExpiresAt: time.Now().Add(auth.TokenTTL).UnixMilli(), ExpiresAt: expiresAt.UnixMilli(),
User: LoginUserDTO{ User: LoginUserDTO{
ID: user.ID, ID: user.ID,
Username: user.Username, Username: user.Username,
+78 -11
View File
@@ -9,17 +9,17 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
"github.com/vaultdrop/backend/pkg/auth" "github.com/kazier/backend/pkg/auth"
"github.com/vaultdrop/backend/pkg/passwd" "github.com/kazier/backend/pkg/passwd"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
"github.com/vaultdrop/backend/service" "github.com/kazier/backend/service"
) )
const authTestURL = "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_handlers_auth_test?sslmode=disable" const authTestURL = "postgres://kazier:kazier@localhost:5432/kazier_handlers_auth_test?sslmode=disable"
const ( const (
authTestPassword = "vaultdrop-test-password" authTestPassword = "kazier-test-password"
authTestDevice = "0123456789abcdef0123456789abcdef" authTestDevice = "0123456789abcdef0123456789abcdef"
) )
@@ -42,6 +42,8 @@ func setTestStore(t *testing.T) *repository.Repository {
func setTestAuth(t *testing.T) { func setTestAuth(t *testing.T) {
t.Helper() t.Helper()
Auth, _ = auth.NewManager("test-secret") Auth, _ = auth.NewManager("test-secret")
ResetLoginRateLimit()
ResetDevicesRateLimit()
t.Cleanup(func() { Auth = nil }) t.Cleanup(func() { Auth = nil })
} }
@@ -202,6 +204,71 @@ func TestAuthLoginWrongCredentials(t *testing.T) {
} }
} }
// TestAuthLoginUnknownUserRegisteredDevice — régression A1 : un username
// inconnu ne doit JAMAIS déréférencer user (panic → 500 via Gin recovery).
// Le device est enregistré pour isoler la branche « user inconnu » : on attend
// 401 UNAUTHORIZED, corps identique au cas « mauvais mot de passe ».
func TestAuthLoginUnknownUserRegisteredDevice(t *testing.T) {
setTestAuth(t)
repo := setTestStore(t)
createAdmin(t, repo, "admin", authTestPassword)
r := newTestRouterForAuth()
doAuth(t, r, http.MethodPost, "/api/v1/devices", "", `{"deviceId":"`+authTestDevice+`"}`)
badPassword := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"wrong-password","device_id":"`+authTestDevice+`"}`)
if badPassword.Code != 401 {
t.Fatalf("mauvais mot de passe: status %d body %s", badPassword.Code, badPassword.Body.String())
}
ghost := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"ghost","password":"wrong-password","device_id":"`+authTestDevice+`"}`)
if ghost.Code != 401 {
t.Fatalf("username inconnu: status %d body %s (attendu 401, jamais 500)", ghost.Code, ghost.Body.String())
}
if !strings.Contains(ghost.Body.String(), "UNAUTHORIZED") {
t.Errorf("code attendu UNAUTHORIZED, got %s", ghost.Body.String())
}
if ghost.Body.String() != badPassword.Body.String() {
t.Errorf("réponses distinguables (sécurité):\n%q\n%q", ghost.Body.String(), badPassword.Body.String())
}
}
func TestAuthLoginRateLimited(t *testing.T) {
setTestAuth(t)
repo := setTestStore(t)
createAdmin(t, repo, "admin", authTestPassword)
r := newTestRouterForAuth()
doAuth(t, r, http.MethodPost, "/api/v1/devices", "", `{"deviceId":"`+authTestDevice+`"}`)
oldLimit := loginRateLimitPerMinute
loginRateLimitPerMinute = 2
hookCalls := 0
oldHook := OnLoginRateLimited
OnLoginRateLimited = func(ip string) { hookCalls++ }
t.Cleanup(func() {
loginRateLimitPerMinute = oldLimit
OnLoginRateLimited = oldHook
ResetLoginRateLimit()
})
badBody := `{"username":"admin","password":"wrong-password","device_id":"` + authTestDevice + `"}`
for i := 0; i < 2; i++ {
if rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", badBody); rec.Code != 401 {
t.Fatalf("tentative %d: status %d, attendu 401", i+1, rec.Code)
}
}
rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", badBody)
if rec.Code != 429 {
t.Fatalf("quota dépassé: status %d body %s, attendu 429", rec.Code, rec.Body.String())
}
if !strings.Contains(rec.Body.String(), "RATE_LIMITED") {
t.Errorf("code attendu RATE_LIMITED, got %s", rec.Body.String())
}
if hookCalls != 1 {
t.Errorf("OnLoginRateLimited appelé %d fois, attendu 1", hookCalls)
}
}
func TestAuthLoginUnregisteredDevice(t *testing.T) { func TestAuthLoginUnregisteredDevice(t *testing.T) {
setTestAuth(t) setTestAuth(t)
repo := setTestStore(t) repo := setTestStore(t)
@@ -209,11 +276,11 @@ func TestAuthLoginUnregisteredDevice(t *testing.T) {
r := newTestRouterForAuth() r := newTestRouterForAuth()
rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"`+authTestPassword+`","device_id":"`+authTestDevice+`"}`) rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"`+authTestPassword+`","device_id":"`+authTestDevice+`"}`)
if rec.Code != 400 { if rec.Code != 401 {
t.Fatalf("device non enregistré: status %d body %s", rec.Code, rec.Body.String()) t.Fatalf("device non enregistré: status %d body %s", rec.Code, rec.Body.String())
} }
if !strings.Contains(rec.Body.String(), "INVALID_DEVICE_ID") { if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") {
t.Errorf("code attendu INVALID_DEVICE_ID, got %s", rec.Body.String()) t.Errorf("code attendu UNAUTHORIZED (anti-oracle), got %s", rec.Body.String())
} }
} }
@@ -311,7 +378,7 @@ func TestResolveUser(t *testing.T) {
t.Errorf("resolve: %+v", env.Data) t.Errorf("resolve: %+v", env.Data)
} }
// Jamais email ni is_admin // Jamais email ni is_admin
if len(rec.Body.Bytes()) < 0 || strings.Contains(rec.Body.String(), "is_admin") || strings.Contains(rec.Body.String(), "email") { if len(rec.Body.Bytes()) == 0 || strings.Contains(rec.Body.String(), "is_admin") || strings.Contains(rec.Body.String(), "email") {
t.Error("resolve ne doit pas exposer email/is_admin") t.Error("resolve ne doit pas exposer email/is_admin")
} }
+66 -2
View File
@@ -1,20 +1,76 @@
package handlers package handlers
import ( import (
"net/http"
"regexp" "regexp"
"sync"
"time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
) )
var deviceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`) var deviceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
// Anti-remplissage de POST /devices (FEEDBACK §moyenne) : l'endpoint est
// public et bon marché (un upsert), donc anonyme et floodable. Limiteur
// basique en mémoire, N enregistrements / minute / IP → 429 RATE_LIMITED.
// Budget large (300) : les usages légitimes (1 device = 1 appel) sont très
// loin du seuil ; la protection vise le flood massif, un WAF frontal fera
// le reste en prod multi-réplicas.
// TODO(suivi) : rate-limit distribué + budget global coordonné avec le
// rate-limit login (cf. handlers/auth.go).
var (
devicesRateLimitPerMinute = 300
devicesRateWindow = time.Minute
devicesAttemptsMu sync.Mutex
devicesAttempts = map[string][]time.Time{}
)
// OnDevicesRateLimited est un hook d'observabilité (nil = no-op).
var OnDevicesRateLimited func(ip string)
// ResetDevicesRateLimit vide le compteur (tests uniquement).
func ResetDevicesRateLimit() {
devicesAttemptsMu.Lock()
defer devicesAttemptsMu.Unlock()
devicesAttempts = map[string][]time.Time{}
}
func devicesRateLimited(ip string, now time.Time) bool {
devicesAttemptsMu.Lock()
defer devicesAttemptsMu.Unlock()
cutoff := now.Add(-devicesRateWindow)
kept := make([]time.Time, 0, len(devicesAttempts[ip])+1)
for _, t := range devicesAttempts[ip] {
if t.After(cutoff) {
kept = append(kept, t)
}
}
if len(kept) >= devicesRateLimitPerMinute {
devicesAttempts[ip] = kept
return true
}
devicesAttempts[ip] = append(kept, now)
return false
}
type DeviceRegisterRequest struct { type DeviceRegisterRequest struct {
DeviceID string `json:"deviceId"` DeviceID string `json:"deviceId"`
} }
func DevicesRegister(c *gin.Context) { func DevicesRegister(c *gin.Context) {
// POST /devices est PUBLIC (sans token) : le device s'enregistre pour
// exister, puis le client appelle POST /auth/login pour obtenir son
// token user-first (cf. docs/api-v1.md §2).
//
// NOTE rate-limit : limiteur en mémoire ci-dessus (300/min/IP, 429
// au-delà). Si le budget doit changer, ajuster
// devicesRateLimitPerMinute + documenter dans docs/api-v1.md.
//
// NOTE MarkUser : repository.Devices.MarkUser retourne ErrNotFound quand
// RowsAffected == 0 (device supprimé entre Exists et UPDATE) ; le login
// mappe ce cas en 401 indistinguable (cf. handlers/auth.go).
var req DeviceRegisterRequest var req DeviceRegisterRequest
if err := c.ShouldBindJSON(&req); err != nil || req.DeviceID == "" { if err := c.ShouldBindJSON(&req); err != nil || req.DeviceID == "" {
api.Error(c, 400, "INVALID_REQUEST", "missing deviceId") api.Error(c, 400, "INVALID_REQUEST", "missing deviceId")
@@ -25,6 +81,14 @@ func DevicesRegister(c *gin.Context) {
return return
} }
if devicesRateLimited(c.ClientIP(), time.Now()) {
if OnDevicesRateLimited != nil {
OnDevicesRateLimited(c.ClientIP())
}
api.Error(c, http.StatusTooManyRequests, "RATE_LIMITED", "too many device registrations, retry later")
return
}
if Store == nil || Store.Repository == nil { if Store == nil || Store.Repository == nil {
api.Error(c, 503, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, 503, "SERVICE_UNAVAILABLE", "backend not initialized")
return return
+113 -18
View File
@@ -7,18 +7,39 @@ import (
"strings" "strings"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/service"
) )
func intParam(value string, fallback int) int { // parsePageParams valide page/pageSize (400 si garbage, cf. FEEDBACK A7/A16)
if value == "" { // au lieu du fallback silencieux. Cap pageSize 200 et offset 100000.
return fallback func parsePageParams(c *gin.Context) (page, pageSize int, ok bool) {
page = 1
pageSize = 50
if v := c.Query("page"); v != "" {
p, err := strconv.Atoi(v)
if err != nil || p < 1 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `page`")
return 0, 0, false
}
page = p
} }
parsed, err := strconv.Atoi(value) if v := c.Query("pageSize"); v != "" {
if err != nil || parsed < 1 { ps, err := strconv.Atoi(v)
return fallback if err != nil || ps < 1 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `pageSize`")
return 0, 0, false
}
pageSize = ps
} }
return parsed if pageSize > 200 {
pageSize = 200
}
if (page-1)*pageSize > 100000 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "page offset too large")
return 0, 0, false
}
return page, pageSize, true
} }
func FilesList(c *gin.Context) { func FilesList(c *gin.Context) {
@@ -27,12 +48,16 @@ func FilesList(c *gin.Context) {
return return
} }
userID := c.GetString(UserIDKey) userID := c.GetString(UserIDKey)
page := intParam(c.Query("page"), 1) page, pageSize, ok := parsePageParams(c)
pageSize := intParam(c.Query("pageSize"), 50) if !ok {
if pageSize > 200 { return
pageSize = 200
} }
files, total, err := Store.ListFiles(userID, c.Query("folderId"), page, pageSize, c.Query("sort"), c.Query("order")) folderID := c.Query("folderId")
if folderID != "" && !deviceIDPattern.MatchString(folderID) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `folderId`")
return
}
files, total, err := Store.ListFiles(userID, folderID, page, pageSize, c.Query("sort"), c.Query("order"))
if err != nil { if err != nil {
writeError(c, err) writeError(c, err)
return return
@@ -59,6 +84,56 @@ func FilesGet(c *gin.Context) {
api.OK(c, file) api.OK(c, file)
} }
// FilesGetOcr expose l'extrait OCR server-side d'un fichier visible (viewer+,
// own ou shared) : GET /files/:id/ocr. Réponse { text } ("" si pas encore
// extrait) + updatedAt. Permet à un second device de récupérer le texte déjà
// calculé sans re-téléverser les octets (cf. docs/api-v1.md §5).
func FilesGetOcr(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
dto, err := Store.GetFileOcr(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, dto)
}
// FilesContent streame les octets physiques d'un fichier visible (viewer+,
// own ou shared) : GET /files/:id/content. Réponse binaire (Content-Type du
// fichier, Content-Disposition inline) — jamais d'enveloppe {data}. Supporte
// Range via http.ServeContent (Gin c.File). Sans bytes serveur (ressource
// metadata-only jamais uploadée) → 404 NOT_FOUND, comme invisible (pas
// d'énumération). V1 streaming : le client ne persiste rien.
func FilesContent(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
info, err := Store.OpenContent(userID, id)
if err != nil {
writeError(c, err)
return
}
c.Header("Content-Type", info.MimeType)
c.Header("Content-Disposition", "inline; filename=\""+info.Name+"\"")
c.File(info.Path)
}
func FilesDelete(c *gin.Context) { func FilesDelete(c *gin.Context) {
if Store == nil { if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -85,6 +160,17 @@ func FilesUpload(c *gin.Context) {
} }
userID := c.GetString(UserIDKey) userID := c.GetString(UserIDKey)
folderID := c.PostForm("folderId") folderID := c.PostForm("folderId")
if folderID != "" && !deviceIDPattern.MatchString(folderID) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `folderId`")
return
}
// resourceId optionnel : cible un fichier déjà connu (metadata-only de
// l'outbox) pour lui attacher ses octets physiques (ex. OCR serveur).
resourceID := c.PostForm("resourceId")
if resourceID != "" && !deviceIDPattern.MatchString(resourceID) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, Store.MaxFileSize+1) c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, Store.MaxFileSize+1)
file, err := c.FormFile("file") file, err := c.FormFile("file")
@@ -102,8 +188,14 @@ func FilesUpload(c *gin.Context) {
return return
} }
dto, err := Store.Upload(userID, file, folderID) dto, err := Store.Upload(userID, file, folderID, resourceID)
if err != nil { if err != nil {
// Nom/extension rejetés côté service (TrimSpace, cap 255,
// anti-slash/retour-ligne, cf. FEEDBACK A16) → 400, jamais 500.
if errors.Is(err, service.ErrInvalidUpload) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid file name")
return
}
writeError(c, err) writeError(c, err)
return return
} }
@@ -135,10 +227,13 @@ func FilesSearch(c *gin.Context) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "missing required query param `q`") api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "missing required query param `q`")
return return
} }
page := intParam(c.Query("page"), 1) if len(q) > 200 {
pageSize := intParam(c.Query("pageSize"), 50) api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `q` too long (max 200)")
if pageSize > 200 { return
pageSize = 200 }
page, pageSize, ok := parsePageParams(c)
if !ok {
return
} }
files, total, err := Store.SearchFiles(userID, q, page, pageSize) files, total, err := Store.SearchFiles(userID, q, page, pageSize)
if err != nil { if err != nil {
+349 -12
View File
@@ -11,15 +11,15 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
"github.com/vaultdrop/backend/handlers" "github.com/kazier/backend/handlers"
"github.com/vaultdrop/backend/pkg/auth" "github.com/kazier/backend/pkg/auth"
"github.com/vaultdrop/backend/pkg/passwd" "github.com/kazier/backend/pkg/passwd"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
"github.com/vaultdrop/backend/service" "github.com/kazier/backend/service"
) )
const handlersTestURL = "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_handlers_test?sslmode=disable" const handlersTestURL = "postgres://kazier:kazier@localhost:5432/kazier_handlers_test?sslmode=disable"
type envelope struct { type envelope struct {
Data json.RawMessage `json:"data"` Data json.RawMessage `json:"data"`
@@ -39,6 +39,11 @@ type fileDTO struct {
CreatedAt string `json:"createdAt"` CreatedAt string `json:"createdAt"`
} }
type fileOcrDTO struct {
Text string `json:"text"`
UpdatedAt string `json:"updatedAt"`
}
type apiError struct { type apiError struct {
Error struct { Error struct {
Code string `json:"code"` Code string `json:"code"`
@@ -68,6 +73,7 @@ func setup(t *testing.T) (*gin.Engine, *service.Resources, *repository.Repositor
} }
handlers.Auth = manager handlers.Auth = manager
handlers.Store = store handlers.Store = store
handlers.ResetDevicesRateLimit()
gin.SetMode(gin.TestMode) gin.SetMode(gin.TestMode)
r := gin.New() r := gin.New()
@@ -183,6 +189,29 @@ func uploadMultipart(t *testing.T, r *gin.Engine, token, folderID, filename stri
return rec return rec
} }
// uploadMultipartToResource uploads bytes targeted at an existing resource_id
// (metadata-only file from the outbox), le cas d'usage OCR.
func uploadMultipartToResource(t *testing.T, r *gin.Engine, token, resourceID, filename string, content []byte) *httptest.ResponseRecorder {
t.Helper()
var body bytes.Buffer
writer := multipart.NewWriter(&body)
part, err := writer.CreateFormFile("file", filename)
if err != nil {
t.Fatalf("create form file: %v", err)
}
if _, err := part.Write(content); err != nil {
t.Fatalf("write body: %v", err)
}
if err := writer.WriteField("resourceId", resourceID); err != nil {
t.Fatalf("write resourceId: %v", err)
}
if err := writer.Close(); err != nil {
t.Fatalf("close writer: %v", err)
}
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/files/upload", token, body.Bytes(), writer.FormDataContentType())
return rec
}
func TestFilesFlow(t *testing.T) { func TestFilesFlow(t *testing.T) {
r, _, repo := setup(t) r, _, repo := setup(t)
deviceA := repository.NewID() deviceA := repository.NewID()
@@ -385,6 +414,67 @@ func TestUploadNameConflict(t *testing.T) {
expectError(t, rec, http.StatusConflict, "NAME_CONFLICT", "upload-dupe") expectError(t, rec, http.StatusConflict, "NAME_CONFLICT", "upload-dupe")
} }
func TestUploadTargetsExistingResource(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, user := registerAndLogin(t, r, repo, testUserUsername(device, "tr"), "upload-test-password", device)
// Fiche metadata-only (même sémantique que l'outbox create_resource).
resourceID := repository.NewID()
if err := repo.Resources.InsertFile(user, resourceID, "scan.png", "", 0, nil, nil); err != nil {
t.Fatalf("insert metadata-only file: %v", err)
}
rec := uploadMultipartToResource(t, r, token, resourceID, "scan.png", []byte("PNGDATA"))
env := expectOK(t, rec, "upload-target")
var uploaded fileDTO
if err := json.Unmarshal(env.Data, &uploaded); err != nil {
t.Fatalf("upload-target: unmarshal: %v", err)
}
if uploaded.ID != resourceID {
t.Errorf("id attendu %s, got %s", resourceID, uploaded.ID)
}
if uploaded.Size != 7 {
t.Errorf("taille = %d, attendu 7", uploaded.Size)
}
// Toujours une seule ligne (pas de doublon).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "")
env = expectOK(t, rec, "list-after-targeted-upload")
var files []fileDTO
if err := json.Unmarshal(env.Data, &files); err != nil {
t.Fatalf("list: unmarshal: %v", err)
}
if len(files) != 1 || files[0].ID != resourceID {
t.Errorf("aucun doublon attendu, got %+v", files)
}
}
func TestUploadTargetForeignResourceNotFound(t *testing.T) {
r, _, repo := setup(t)
deviceA := repository.NewID()
deviceB := repository.NewID()
tokenA, _ := registerAndLogin(t, r, repo, testUserUsername(deviceA, "tf"), "upload-test-password", deviceA)
_, userB := registerAndLogin(t, r, repo, testUserUsername(deviceB, "tg"), "upload-test-password-b", deviceB)
resourceID := repository.NewID()
if err := repo.Resources.InsertFile(userB, resourceID, "mine.png", "", 0, nil, nil); err != nil {
t.Fatalf("insert B file: %v", err)
}
rec := uploadMultipartToResource(t, r, tokenA, resourceID, "mine.png", []byte("DATA"))
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "upload-foreign")
}
func TestUploadTargetInvalidID(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ti"), "upload-test-password", device)
rec := uploadMultipartToResource(t, r, token, "NOT-HEX", "x.png", []byte("DATA"))
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "upload-invalid-id")
}
func TestFoldersListAndScoping(t *testing.T) { func TestFoldersListAndScoping(t *testing.T) {
r, _, repo := setup(t) r, _, repo := setup(t)
deviceA := repository.NewID() deviceA := repository.NewID()
@@ -428,12 +518,12 @@ func TestFilesPaginationDefaultsAndClamp(t *testing.T) {
t.Errorf("clamp pageSize: %+v", env.Meta) t.Errorf("clamp pageSize: %+v", env.Meta)
} }
// Paramètres invalides → défauts (page=1, pageSize=50) // Paramètres invalides → 400 (plus de fallback silencieux, cf. A16).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=0&pageSize=-5", token, nil, "") rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=0&pageSize=-5", token, nil, "")
env = expectOK(t, rec, "invalid-params") expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "negative-params")
if env.Meta == nil || env.Meta.Page != 1 || env.Meta.PageSize != 50 {
t.Errorf("defauts page/pageSize: %+v", env.Meta) rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=abc&pageSize=zz", token, nil, "")
} expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "garbage-params")
// sort/order inconnus → pas d'erreur (défaut created_at desc) // sort/order inconnus → pas d'erreur (défaut created_at desc)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?sort=zzz&order=up&pageSize=10", token, nil, "") rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?sort=zzz&order=up&pageSize=10", token, nil, "")
@@ -493,3 +583,250 @@ func TestFilesGetDeleteRejectInvalidID(t *testing.T) {
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, otherToken, nil, "") rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, otherToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "get-cross-user") expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "get-cross-user")
} }
func TestFilesGetOcrOwnerShareAndScoping(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "oc"), "ocr-get-test-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "og"), "ocr-get-test-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "oh"), "ocr-get-test-password-c", outsiderDevice)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "scan.png", "", 128, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
if err := repo.Resources.UpdateOcrText(owner, fileID, "extrait du scan"); err != nil {
t.Fatalf("write ocr_text: %v", err)
}
// Owner : texte + updatedAt.
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/ocr", ownerToken, nil, "")
envOcr := expectOK(t, rec, "ocr-owner")
var ownerOcr fileOcrDTO
if err := json.Unmarshal(envOcr.Data, &ownerOcr); err != nil {
t.Fatalf("ocr-owner: unmarshal: %v", err)
}
if ownerOcr.Text != "extrait du scan" || ownerOcr.UpdatedAt == "" {
t.Errorf("ocr owner = %+v, attendu texte+updatedAt", ownerOcr)
}
// Grantée viewer+ : même texte (partage rend l'OCR lisible).
if err := repo.Shares.Upsert(fileID, grantee, "viewer", false, nil, owner); err != nil {
t.Fatalf("share: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/ocr", granteeToken, nil, "")
envOcr = expectOK(t, rec, "ocr-grantee")
var granteeOcr fileOcrDTO
if err := json.Unmarshal(envOcr.Data, &granteeOcr); err != nil {
t.Fatalf("ocr-grantee: unmarshal: %v", err)
}
if granteeOcr.Text != "extrait du scan" {
t.Errorf("ocr grantee = %+v, attendu texte partagé", granteeOcr)
}
// Outsider : invisible (404).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/ocr", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "ocr-outsider")
// ID invalide → 404.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/ocr", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "ocr-invalid-id")
}
func TestFilesUploadRejectsBadFilename(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "bn"), "badname-test-password", device)
// Body multipart construit à la main : filename brut, NON neutralisé par
// le writer stdlib (qui basename/encode de son côté). Le serveur doit
// rejeter en 400, jamais 500 (cf. A16).
rawUpload := func(filename string) *httptest.ResponseRecorder {
t.Helper()
boundary := "testboundary123"
body := "--" + boundary + "\r\n" +
"Content-Disposition: form-data; name=\"file\"; filename=\"" + filename + "\"\r\n" +
"Content-Type: application/octet-stream\r\n\r\n" +
"hi\r\n" +
"--" + boundary + "--\r\n"
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/files/upload", token, []byte(body), "multipart/form-data; boundary="+boundary)
return rec
}
rec := rawUpload("../../evil.txt")
// La stdlib Go basename déjà côté lecture (défense en profondeur côté
// service via sanitizeFileName, testé en unitaire + backslash) : le nom
// stocké est "evil.txt" et aucun chemin ne s'échappe (destPath dérivé
// uniquement de IDs 32-hex + extension sanitizée).
env := expectOK(t, rec, "upload-traversal-name")
var uploaded fileDTO
if err := json.Unmarshal(env.Data, &uploaded); err != nil {
t.Fatalf("upload-traversal-name: unmarshal: %v", err)
}
if uploaded.Name != "evil.txt" {
t.Errorf("nom traversal neutralisé attendu \"evil.txt\", got %q", uploaded.Name)
}
// Backslash : préservé par la stdlib → rejet service 400, jamais 500.
rec = rawUpload(`bad\name.txt`)
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "upload-backslash-name")
}
func TestSearchQTooLong(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ql"), "search-test-password", device)
long := make([]byte, 201)
for i := range long {
long[i] = 'a'
}
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-q-too-long")
}
func TestFilesContentStreaming(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "ct"), "content-test-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "cg"), "content-test-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "ch"), "content-test-password-c", outsiderDevice)
// Ressource metadata-only (outbox) puis upload ciblé des octets (≤10o, cf. setup).
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "note.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
rec := uploadMultipartToResource(t, r, ownerToken, fileID, "note.txt", []byte("hello"))
if rec.Code != http.StatusOK {
t.Fatalf("upload ciblé: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
// Owner : octets + Content-Type.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", ownerToken, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("content-owner: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
if rec.Body.String() != "hello" {
t.Errorf("content-owner = %q, attendu %q", rec.Body.String(), "hello")
}
if ct := rec.Header().Get("Content-Type"); ct == "" {
t.Errorf("content-owner: Content-Type manquant")
}
// Grantée viewer : mêmes octets (résolution dir owner, pas requester).
if err := repo.Shares.Upsert(fileID, grantee, "viewer", false, nil, owner); err != nil {
t.Fatalf("share: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", granteeToken, nil, "")
if rec.Code != http.StatusOK || rec.Body.String() != "hello" {
t.Errorf("content-grantee: attendu 200 hello, got %d %q", rec.Code, rec.Body.String())
}
// Outsider : 404 (pas d'énumération).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-outsider")
// Metadata-only sans octets : 404 (jamais uploadé).
bareID := repository.NewID()
if err := repo.Resources.InsertFile(owner, bareID, "vide.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert bare: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+bareID+"/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-no-bytes")
// ID invalide → 404 ; sans token → 401.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-invalid-id")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", "", nil, "")
if rec.Code != http.StatusUnauthorized {
t.Errorf("content-sans-token: attendu 401, got %d", rec.Code)
}
}
func TestFilesSharesLinksListing(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "sl"), "shares-list-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "sg"), "shares-list-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "sh"), "shares-list-password-c", outsiderDevice)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "shared.txt", "", 4, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
// Vide au départ (pas d'erreur).
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", ownerToken, nil, "")
env := expectOK(t, rec, "shares-empty")
var emptyShares []map[string]any
if err := json.Unmarshal(env.Data, &emptyShares); err != nil {
t.Fatalf("shares-empty: unmarshal: %v", err)
}
if len(emptyShares) != 0 {
t.Errorf("shares-empty = %d grants, attendu 0", len(emptyShares))
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/links", ownerToken, nil, "")
env = expectOK(t, rec, "links-empty")
var emptyLinks []map[string]any
if err := json.Unmarshal(env.Data, &emptyLinks); err != nil {
t.Fatalf("links-empty: unmarshal: %v", err)
}
if len(emptyLinks) != 0 {
t.Errorf("links-empty = %d links, attendu 0", len(emptyLinks))
}
// Un grant + un lien côté serveur (comme après des ops `share`/`create_link`).
if err := repo.Shares.Upsert(fileID, grantee, "editor", true, nil, owner); err != nil {
t.Fatalf("share: %v", err)
}
linkToken := repository.NewID()
if err := repo.Shares.CreateLink(linkToken, fileID, "viewer", nil, owner); err != nil {
t.Fatalf("create link: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", ownerToken, nil, "")
env = expectOK(t, rec, "shares-owner")
var grants []struct {
GranteeUserID string `json:"granteeUserId"`
Username string `json:"username"`
Access string `json:"access"`
}
if err := json.Unmarshal(env.Data, &grants); err != nil {
t.Fatalf("shares-owner: unmarshal: %v", err)
}
if len(grants) != 1 || grants[0].GranteeUserID != grantee || grants[0].Access != "editor" || grants[0].Username == "" {
t.Errorf("shares-owner = %+v, attendu 1 grant editor du grantee", grants)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/links", ownerToken, nil, "")
env = expectOK(t, rec, "links-owner")
var links []struct {
Token string `json:"token"`
Access string `json:"access"`
}
if err := json.Unmarshal(env.Data, &links); err != nil {
t.Fatalf("links-owner: unmarshal: %v", err)
}
if len(links) != 1 || links[0].Token != linkToken || links[0].Access != "viewer" {
t.Errorf("links-owner = %+v, attendu 1 lien viewer", links)
}
// Granté et outsider : 404 (pas d'énumération).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", granteeToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "shares-grantee")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/links", granteeToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "links-grantee")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "shares-outsider")
// ID invalide → 404.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/shares", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "shares-invalid-id")
}
+1 -1
View File
@@ -2,7 +2,7 @@ package handlers
import ( import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
) )
func Health(c *gin.Context) { func Health(c *gin.Context) {
+126
View File
@@ -0,0 +1,126 @@
package handlers_test
// Tests contrat LOT 6 : ordre statique/param (§1), validation 32-hex et
// curseur `after` stricts (A7), validation POST /devices.
import (
"net/http"
"net/http/httptest"
"testing"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/handlers"
"github.com/kazier/backend/repository"
)
// TestFoldersRouteServesListNotParam (§1) : GET /files/folders via le routeur
// atteint FoldersList (200), jamais FilesGet avec id="folders".
func TestFoldersRouteServesListNotParam(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "l6f"), "lot6-test-password", device)
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/folders", token, nil, "")
expectOK(t, rec, "folders-static-wins")
}
// TestFilesGetRejectsFoldersLiteral (§1) : si le routeur tombait un jour sur
// FilesGet avec id="folders", le garde 32-hex répond 404 (jamais 200, jamais
// 500). Appel direct du handler pour forcer le cas paramétré.
func TestFilesGetRejectsFoldersLiteral(t *testing.T) {
setup(t)
gin.SetMode(gin.TestMode)
w := httptest.NewRecorder()
c, _ := gin.CreateTestContext(w)
c.Request = httptest.NewRequest(http.MethodGet, "/api/v1/files/folders", nil)
c.Params = gin.Params{{Key: "id", Value: "folders"}}
c.Set(handlers.UserIDKey, "00000000000000000000000000000001")
handlers.FilesGet(c)
expectError(t, w, http.StatusNotFound, "NOT_FOUND", "files-get-folders-literal")
}
// TestShareLinkMalformedToken400 (A7) : token non 32-hex → 400
// INVALID_REQUEST (pas 404).
func TestShareLinkMalformedToken400(t *testing.T) {
r, _, _ := setup(t)
for _, path := range []string{
"/api/v1/shares/links/NOT-HEX",
"/api/v1/shares/links/xyz",
"/api/v1/shares/links/ABCDEF0123456789ABCDEF0123456789", // majuscules rejetées
} {
rec, _ := doRequest(t, r, http.MethodGet, path, "", nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "share-malformed-token")
}
}
// TestSyncPermissionsAfterValidation (A7) : garbage/négatif → 400, epoch-ms
// 64-bit accepté.
func TestSyncPermissionsAfterValidation(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "l6a"), "lot6-test-password", device)
for _, path := range []string{
"/api/v1/sync/permissions?after=garbage",
"/api/v1/sync/permissions?after=-5",
"/api/v1/sync/permissions?after=12.5",
"/api/v1/sync/permissions?after=",
} {
// "?after=" vide = curseur absent → 200 (seul le dernier cas).
rec, _ := doRequest(t, r, http.MethodGet, path, token, nil, "")
if path == "/api/v1/sync/permissions?after=" {
expectOK(t, rec, "after-empty-ok")
} else {
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "after-invalid:"+path)
}
}
// Epoch-ms au-delà de 2^31 (64-bit) → 200, pas de troncation/rejet.
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/sync/permissions?after=9999999999999", token, nil, "")
expectOK(t, rec, "after-64bit-ok")
}
// TestDevicesRegisterValidation : 32-hex malformé/absent → 400, valide → 200.
func TestDevicesRegisterValidation(t *testing.T) {
r, _, _ := setup(t)
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":"NOT-HEX"}`), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_DEVICE_ID", "devices-malformed")
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{}`), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "devices-missing")
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json")
expectOK(t, rec, "devices-valid")
}
// TestDevicesRegisterRateLimited : flood → 429 RATE_LIMITED (budget 300/min/IP,
// cf. handlers/devices.go). Les requêtes invalides ne consomment pas le budget.
func TestDevicesRegisterRateLimited(t *testing.T) {
r, _, _ := setup(t)
hookCalls := 0
handlers.OnDevicesRateLimited = func(ip string) { hookCalls++ }
t.Cleanup(func() { handlers.OnDevicesRateLimited = nil })
// Les requêtes invalides (avant le compteur) ne doivent pas déclencher.
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":"BAD"}`), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_DEVICE_ID", "devices-ratelimit-invalid")
for i := 0; i < 300; i++ {
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json")
if rec.Code != http.StatusOK {
t.Fatalf("enregistrement %d: attendu 200, got %d body=%s", i, rec.Code, rec.Body.String())
}
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json")
expectError(t, rec, http.StatusTooManyRequests, "RATE_LIMITED", "devices-ratelimited")
if hookCalls != 1 {
t.Errorf("OnDevicesRateLimited appelé %d fois, attendu 1", hookCalls)
}
}
+36 -4
View File
@@ -2,13 +2,14 @@ package handlers
import ( import (
"errors" "errors"
"log"
"net/http" "net/http"
"strings" "strings"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/vaultdrop/backend/pkg/auth" "github.com/kazier/backend/pkg/auth"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
const ( const (
@@ -19,6 +20,15 @@ const (
// Auth issues/verifies device bearer tokens; set once at startup (cmd/server). // Auth issues/verifies device bearer tokens; set once at startup (cmd/server).
var Auth *auth.Manager var Auth *auth.Manager
// EnforceDeviceExists durcit RequireAuth (FEEDBACK A15) : quand true, le
// device_id porté par le token doit exister en base (POST /devices), sinon la
// requête est rejetée en 401 et le rejet est loggé côté serveur.
// Défaut false (V1) : le device reste un claim porté NON autorisant —
// l'autorisation vient du subject user_id + existence du compte. Passer à true
// coûte une lecture DB par requête authentifiée ; ne pas activer sans mesurer
// sur les routes à fort trafic (snapshot/sync).
var EnforceDeviceExists = false
// RequireAuth authenticates the bearer paseto token. Le subject (user_id) // RequireAuth authenticates the bearer paseto token. Le subject (user_id)
// autorise — c'est la clé de scoping de toutes les ressources ; device_id est // autorise — c'est la clé de scoping de toutes les ressources ; device_id est
// porté (non autorisant) pour l'idempotence outbox et les jobs OCR. Le compte // porté (non autorisant) pour l'idempotence outbox et les jobs OCR. Le compte
@@ -26,7 +36,13 @@ var Auth *auth.Manager
func RequireAuth(c *gin.Context) { func RequireAuth(c *gin.Context) {
header := c.GetHeader("Authorization") header := c.GetHeader("Authorization")
token, found := strings.CutPrefix(header, "Bearer ") token := ""
found := false
// Préfixe Bearer insensible à la casse (cf. FEEDBACK A7).
if len(header) > 7 && strings.EqualFold(header[:7], "Bearer ") {
token = strings.TrimSpace(header[7:])
found = token != ""
}
if Auth == nil || !found || token == "" { if Auth == nil || !found || token == "" {
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "missing bearer token") api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "missing bearer token")
@@ -57,6 +73,22 @@ func RequireAuth(c *gin.Context) {
} }
} }
if EnforceDeviceExists && Store != nil && Store.Repository != nil {
// Verify garantit déjà le format 32-hex : Exists reçoit une entrée saine.
exists, err := Store.Repository.Devices.Exists(identity.DeviceID)
if err != nil {
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not check device")
c.Abort()
return
}
if !exists {
log.Printf("auth: token d'un device inconnu rejeté (user=%s device=%s)", identity.UserID, identity.DeviceID)
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "unknown device")
c.Abort()
return
}
}
c.Set(UserIDKey, identity.UserID) c.Set(UserIDKey, identity.UserID)
c.Set(DeviceIDKey, identity.DeviceID) c.Set(DeviceIDKey, identity.DeviceID)
c.Next() c.Next()
+60
View File
@@ -0,0 +1,60 @@
package handlers
import (
"net/http"
"strings"
"testing"
)
const middlewareUnknownDevice = "ffffffffffffffffffffffffffffffff"
// Par défaut (EnforceDeviceExists=false), un token portant un device inconnu
// passe le middleware : le device est un claim non autorisant (V1).
func TestRequireAuthUnknownDevicePassesByDefault(t *testing.T) {
setTestAuth(t)
repo := setTestStore(t)
userID := createAdmin(t, repo, "admin", authTestPassword)
r := newTestRouterForAuth()
if EnforceDeviceExists {
t.Fatal("EnforceDeviceExists devrait être false par défaut")
}
signed, err := Auth.Issue(userID, middlewareUnknownDevice)
if err != nil {
t.Fatalf("issue: %v", err)
}
rec := doAuth(t, r, http.MethodGet, "/api/v1/files", signed, "")
if rec.Code == 401 {
t.Fatalf("device inconnu rejeté alors que EnforceDeviceExists=false: %s", rec.Body.String())
}
}
// Avec EnforceDeviceExists=true, le device inconnu est rejeté en 401 (et
// loggé), le device enregistré passe.
func TestRequireAuthEnforceDeviceExists(t *testing.T) {
setTestAuth(t)
repo := setTestStore(t)
userID := createAdmin(t, repo, "admin", authTestPassword)
_ = repo.Devices.Upsert(authTestDevice)
r := newTestRouterForAuth()
old := EnforceDeviceExists
EnforceDeviceExists = true
t.Cleanup(func() { EnforceDeviceExists = old })
unknown, _ := Auth.Issue(userID, middlewareUnknownDevice)
rec := doAuth(t, r, http.MethodGet, "/api/v1/files", unknown, "")
if rec.Code != 401 {
t.Fatalf("device inconnu: status %d body %s, attendu 401", rec.Code, rec.Body.String())
}
if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") {
t.Errorf("code attendu UNAUTHORIZED, got %s", rec.Body.String())
}
known, _ := Auth.Issue(userID, authTestDevice)
rec = doAuth(t, r, http.MethodGet, "/api/v1/files", known, "")
if rec.Code == 401 {
t.Fatalf("device enregistré rejeté avec EnforceDeviceExists=true: %s", rec.Body.String())
}
}
+2 -2
View File
@@ -5,8 +5,8 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
type ocrJobRequest struct { type ocrJobRequest struct {
+12 -5
View File
@@ -11,11 +11,11 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
"github.com/vaultdrop/backend/handlers" "github.com/kazier/backend/handlers"
"github.com/vaultdrop/backend/pkg/auth" "github.com/kazier/backend/pkg/auth"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
"github.com/vaultdrop/backend/service" "github.com/kazier/backend/service"
) )
type stubEngine struct { type stubEngine struct {
@@ -40,8 +40,15 @@ func setupOcr(t *testing.T) (*gin.Engine, string, *repository.Repository) {
manager, _ := auth.NewManager("test-secret") manager, _ := auth.NewManager("test-secret")
handlers.Auth = manager handlers.Auth = manager
handlers.Store = store handlers.Store = store
handlers.ResetDevicesRateLimit()
handlers.Ocr = service.NewOcr(repo, uploadDir, "fra+eng", stubEngine{text: "HELLO OCR"}) handlers.Ocr = service.NewOcr(repo, uploadDir, "fra+eng", stubEngine{text: "HELLO OCR"})
// Worker OCR borné — le handler n'enfile plus que le job, le traitement
// tourne sur un worker de contexte.
ctx, cancel := context.WithCancel(context.Background())
go handlers.Ocr.Run(ctx, 1)
t.Cleanup(cancel)
gin.SetMode(gin.TestMode) gin.SetMode(gin.TestMode)
r := gin.New() r := gin.New()
handlers.RegisterRoutes(r) handlers.RegisterRoutes(r)
+11 -11
View File
@@ -2,11 +2,10 @@ package handlers
import ( import (
"net/http" "net/http"
"strings"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
) )
// RegisterRoutes wires the full /api/v1 surface (public + protected). // RegisterRoutes wires the full /api/v1 surface (public + protected).
@@ -26,10 +25,18 @@ func RegisterRoutes(r *gin.Engine) {
protected.Use(RequireAuth) protected.Use(RequireAuth)
{ {
protected.GET("/files", FilesList) protected.GET("/files", FilesList)
// Verrou LOT 6 §1 : les routes statiques restent déclarées AVANT
// /files/:id (Gin priorise déjà le statique sur le paramétré, mais
// l'ordre source verrouille l'intention : /files/folders ne doit
// jamais être avalé par FilesGet avec id="folders").
protected.GET("/files/search", FilesSearch) protected.GET("/files/search", FilesSearch)
protected.GET("/files/:id", FilesGet)
protected.DELETE("/files/:id", FilesDelete)
protected.GET("/files/folders", FoldersList) protected.GET("/files/folders", FoldersList)
protected.GET("/files/:id", FilesGet)
protected.GET("/files/:id/ocr", FilesGetOcr)
protected.GET("/files/:id/content", FilesContent)
protected.GET("/files/:id/shares", SharesList)
protected.GET("/files/:id/links", LinksList)
protected.DELETE("/files/:id", FilesDelete)
protected.POST("/files/upload", FilesUpload) protected.POST("/files/upload", FilesUpload)
protected.GET("/users/resolve", ResolveUser) protected.GET("/users/resolve", ResolveUser)
@@ -47,10 +54,3 @@ func RegisterRoutes(r *gin.Engine) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "route not found") api.Error(c, http.StatusNotFound, "NOT_FOUND", "route not found")
}) })
} }
// userID lit la clé de scoping posée par RequireAuth. Un empty string est
// impossible en conditions normales (le middleware l'a validé) ; garde-fou
// pour un appel direct dans les tests.
func userID(c *gin.Context) string {
return strings.TrimSpace(c.GetString(UserIDKey))
}
+13 -3
View File
@@ -1,12 +1,13 @@
package handlers package handlers
import ( import (
"errors"
"net/http" "net/http"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
// ShareLinkGet resolves a public share link without authentication // ShareLinkGet resolves a public share link without authentication
@@ -18,9 +19,18 @@ func ShareLinkGet(c *gin.Context) {
return return
} }
token := c.Param("token") token := c.Param("token")
// Contrat V1 : les tokens de lien sont du 32-hex (cf. docs/api-v1.md).
// Malformé → 400 INVALID_REQUEST (pas 404 : ce n'est pas « introuvable »,
// c'est « requête invalide »). deviceIDPattern (devices.go, même package)
// exprime exactement ce format.
if !deviceIDPattern.MatchString(token) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "malformed link token")
return
}
link, err := Store.Repository.Shares.GetPublicLink(token) link, err := Store.Repository.Shares.GetPublicLink(token)
if err != nil { if err != nil {
if err == repository.ErrNotFound { // A6 : errors.Is (pas ==) — le repo peut envelopper ErrNotFound.
if errors.Is(err, repository.ErrNotFound) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "link not found or revoked") api.Error(c, http.StatusNotFound, "NOT_FOUND", "link not found or revoked")
return return
} }
+1 -1
View File
@@ -5,7 +5,7 @@ import (
"net/http" "net/http"
"testing" "testing"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
func TestShareLinkPublicResolution(t *testing.T) { func TestShareLinkPublicResolution(t *testing.T) {
+52
View File
@@ -0,0 +1,52 @@
package handlers
import (
"net/http"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
)
// SharesList exposes the active user-to-user grants of a resource the caller
// OWNS : GET /files/:id/shares. Non-owner (or unknown resource) → 404
// NOT_FOUND (no enumeration, same scoping as the share outbox ops).
func SharesList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
grants, err := Store.ListShares(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, grants)
}
// LinksList exposes the active public links of a resource the caller OWNS :
// GET /files/:id/links. Same owner-only scoping as SharesList.
func LinksList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
links, err := Store.ListLinks(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, links)
}
+13 -5
View File
@@ -2,11 +2,12 @@ package handlers
import ( import (
"errors" "errors"
"log"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
"github.com/vaultdrop/backend/service" "github.com/kazier/backend/service"
) )
// Store is the business layer used by handlers; set once at startup // Store is the business layer used by handlers; set once at startup
@@ -25,9 +26,16 @@ func writeError(c *gin.Context, err error) {
api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist") api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist")
case errors.Is(err, repository.ErrNameConflict): case errors.Is(err, repository.ErrNameConflict):
api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here") api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here")
case errors.Is(err, service.FileTooLargeError): case errors.Is(err, service.ErrFileTooLarge):
api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size") api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size")
default: default:
api.Error(c, 500, "INTERNAL", err.Error()) // Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf.
// FEEDBACK #8) : message générique, détail au log serveur.
path := ""
if c.Request != nil && c.Request.URL != nil {
path = c.Request.URL.Path
}
log.Printf("internal error: path=%s err=%v", path, err)
api.Error(c, 500, "INTERNAL", "internal error")
} }
} }
+39 -6
View File
@@ -2,17 +2,45 @@ package handlers
import ( import (
"net/http" "net/http"
"strconv"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/vaultdrop/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/vaultdrop/backend/service" "github.com/kazier/backend/service"
) )
// parseAfterMs parses the `after` delta cursor of GET /sync/permissions :
// epoch-millis, 64-bit (les curseurs dépassent 2^31). Chaîne vide → 0 (sync
// complet). Garbage ou négatif → ok=false : le handler répond 400
// INVALID_REQUEST, jamais de repli silencieux vers 0 (un curseur malformé
// pris pour « sync complet » masquerait une désynchro client).
// NOTE : la pagination (files.go) répond 400 sur page/pageSize malformés,
// jamais de repli silencieux vers un défaut (un curseur malformé pris pour
// « sync complet » masquerait une désynchro client).
func parseAfterMs(raw string) (int64, bool) {
if raw == "" {
return 0, true
}
ms, err := strconv.ParseInt(raw, 10, 64)
if err != nil || ms < 0 {
return 0, false
}
return ms, true
}
type syncOpsRequest struct { type syncOpsRequest struct {
Operations []service.SyncOperation `json:"operations"` Operations []service.SyncOperation `json:"operations"`
} }
// Bornes anti-DoS de POST /sync/ops (FEEDBACK §moyenne) : le client envoie des
// batchs de 20 ; au-delà de 100 ops ou 1 MiB de body → rejet explicite, jamais
// d'OOM sur batch géant.
const (
maxSyncOpsBodyBytes = 1 << 20
maxSyncOpsPerBatch = 100
)
func SyncOpsPush(c *gin.Context) { func SyncOpsPush(c *gin.Context) {
if Store == nil { if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -20,11 +48,16 @@ func SyncOpsPush(c *gin.Context) {
} }
userID := c.GetString(UserIDKey) userID := c.GetString(UserIDKey)
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxSyncOpsBodyBytes)
var req syncOpsRequest var req syncOpsRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body") api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
return return
} }
if len(req.Operations) > maxSyncOpsPerBatch {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "too many operations in batch (max 100)")
return
}
result, err := Store.ApplyBatch(userID, c.GetString(DeviceIDKey), req.Operations) result, err := Store.ApplyBatch(userID, c.GetString(DeviceIDKey), req.Operations)
if err != nil { if err != nil {
@@ -40,10 +73,10 @@ func SyncPermissionsGet(c *gin.Context) {
return return
} }
userID := c.GetString(UserIDKey) userID := c.GetString(UserIDKey)
after := c.Query("after") afterMs, ok := parseAfterMs(c.Query("after"))
var afterMs int64 if !ok {
if after != "" { api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `after` cursor, must be non-negative epoch-millis")
afterMs = int64(intParam(after, 0)) return
} }
perms, err := Store.Snapshot(userID, afterMs) perms, err := Store.Snapshot(userID, afterMs)
if err != nil { if err != nil {
+15 -1
View File
@@ -6,7 +6,7 @@ import (
"net/http" "net/http"
"testing" "testing"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
func syncOpsBody(ops []map[string]any) []byte { func syncOpsBody(ops []map[string]any) []byte {
@@ -254,6 +254,20 @@ func TestSyncOpsLargeBatchAccepted(t *testing.T) {
} }
} }
func TestSyncOpsBatchTooLargeRejected(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "sx"), "sync-test-password", device)
ops := make([]map[string]any, 0, 101)
for i := 0; i < 101; i++ {
ops = append(ops, op(repository.NewID(), repository.NewID(), "create_resource", "file", map[string]any{"name": fmt.Sprintf("g%03d.txt", i)}))
}
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/sync/ops", token, syncOpsBody(ops), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "sync-batch-too-large")
}
func TestSyncOpsStopsAtFirstNonIdempotentFailure(t *testing.T) { func TestSyncOpsStopsAtFirstNonIdempotentFailure(t *testing.T) {
r, _, repo := setup(t) r, _, repo := setup(t)
device := repository.NewID() device := repository.NewID()
+3 -3
View File
@@ -8,19 +8,19 @@ type Client interface {
GetClientVersion() int GetClientVersion() int
} }
func NewClient(clientVersion int) (error, Client) { func NewClient(clientVersion int) (Client, error) {
isCompatible := ServerClientIsCompatibleWithClient(clientVersion) isCompatible := ServerClientIsCompatibleWithClient(clientVersion)
if !isCompatible { if !isCompatible {
return fmt.Errorf("You client version %d is not compatible with the server verison %d", clientVersion, SERVER_VERSION), nil return nil, fmt.Errorf("client version %d is not compatible with the server version %d", clientVersion, SERVER_VERSION)
} }
client := ClientVerisonOne{ client := ClientVerisonOne{
Version: clientVersion, Version: clientVersion,
} }
return nil, &client return &client, nil
} }
+5 -5
View File
@@ -1,7 +1,7 @@
package models package models
import ( import (
"fmt" "errors"
) )
type Document struct { type Document struct {
@@ -37,19 +37,19 @@ func IsDirectory(documentType int) bool {
return DIRECTORY == documentType return DIRECTORY == documentType
} }
func NewDocument(documentName string, documentType int, documentVersion int) (error, *Document) { func NewDocument(documentName string, documentType int, documentVersion int) (*Document, error) {
documentTypeIsValid := IsDocumentTypeValid(documentType) documentTypeIsValid := IsDocumentTypeValid(documentType)
if !documentTypeIsValid { if !documentTypeIsValid {
return fmt.Errorf(ERROR_DOCUMENT_TYPE), nil return nil, errors.New(ERROR_DOCUMENT_TYPE)
} }
return nil, &Document{ return &Document{
Name: &documentName, Name: &documentName,
Type: documentType, Type: documentType,
Version: documentVersion, Version: documentVersion,
} }, nil
} }
+3 -3
View File
@@ -4,8 +4,8 @@ type User struct {
Username string Username string
} }
func NewUser(username string) (error, *User) { func NewUser(username string) (*User, error) {
return nil, &User{ return &User{
Username: username, Username: username,
} }, nil
} }
+85 -8
View File
@@ -4,13 +4,42 @@ import (
"bytes" "bytes"
"context" "context"
"errors" "errors"
"fmt"
"os/exec" "os/exec"
"path/filepath" "path/filepath"
"strings" "strings"
"time"
"github.com/ledongthuc/pdf" "github.com/ledongthuc/pdf"
) )
const (
// tesseractTimeout : budget max par job (A13) — Tesseract ne doit jamais
// bloquer un worker indéfiniment (image pathologique).
tesseractTimeout = 120 * time.Second
// outputCap : plafond stdout/stderr capturés (A13, 2 Mo) — un document
// hostile ne doit pas faire exploser la RAM du worker.
outputCap = 2 << 20
// maxPDFPages : plafond de pages lues (A13) — au-delà, erreur explicite
// (pas de troncature silencieuse).
maxPDFPages = 50
)
// validTesseractLang : whitelist `^[a-z+]{2,20}$` (A12, défense en profondeur
// — le point d'entrée normal est service.normalizeOcrLang). Évite toute
// injection via `tesseract -l` (espaces, `;`, options `--...`).
func validTesseractLang(lang string) bool {
if len(lang) < 2 || len(lang) > 20 {
return false
}
for _, r := range lang {
if (r < 'a' || r > 'z') && r != '+' {
return false
}
}
return true
}
// TesseractEngine runs the `tesseract` binary in a subprocess. // TesseractEngine runs the `tesseract` binary in a subprocess.
// Images are OCR'd directly; PDFs have their text layer extracted first // Images are OCR'd directly; PDFs have their text layer extracted first
// (scanned PDFs → empty text, no rendering pipeline in V1). // (scanned PDFs → empty text, no rendering pipeline in V1).
@@ -18,20 +47,55 @@ type TesseractEngine struct{}
func NewTesseract() *TesseractEngine { return &TesseractEngine{} } func NewTesseract() *TesseractEngine { return &TesseractEngine{} }
// ExtractText implements Engine. // ExtractText implements Engine. Chaque job est borné par tesseractTimeout
// (contexte dérivé, annulé en fin d'appel).
func (t *TesseractEngine) ExtractText(ctx context.Context, filePath, lang string) (string, error) { func (t *TesseractEngine) ExtractText(ctx context.Context, filePath, lang string) (string, error) {
ctx, cancel := context.WithTimeout(ctx, tesseractTimeout)
defer cancel()
if strings.ToLower(filepath.Ext(filePath)) == ".pdf" { if strings.ToLower(filepath.Ext(filePath)) == ".pdf" {
return extractPDFText(filePath) return extractPDFText(ctx, filePath)
} }
return runTesseract(ctx, filePath, lang) return runTesseract(ctx, filePath, lang)
} }
// cappedBuffer borne un flux capturé à `limit` octets et signale la
// troncature (erreur explicite côté appelant, pas de coupe silencieuse).
type cappedBuffer struct {
buf bytes.Buffer
limit int
truncated bool
}
func (c *cappedBuffer) Write(p []byte) (int, error) {
remaining := c.limit - c.buf.Len()
if remaining <= 0 {
c.truncated = true
return len(p), nil // déverse : le process ne bloque pas sur un pipe plein
}
if len(p) > remaining {
c.truncated = true
p = p[:remaining]
}
return c.buf.Write(p)
}
func (c *cappedBuffer) String() string { return c.buf.String() }
func runTesseract(ctx context.Context, filePath, lang string) (string, error) { func runTesseract(ctx context.Context, filePath, lang string) (string, error) {
// Défense en profondeur (A12) : même si l'appelant ne passe pas par
// service.normalizeOcrLang, `-l` ne reçoit jamais de métacaractères.
if !validTesseractLang(lang) {
return "", fmt.Errorf("tesseract: langue %q invalide", lang)
}
cmd := exec.CommandContext(ctx, "tesseract", filePath, "stdout", "-l", lang) cmd := exec.CommandContext(ctx, "tesseract", filePath, "stdout", "-l", lang)
var stdout, stderr bytes.Buffer stdout := &cappedBuffer{limit: outputCap}
cmd.Stdout = &stdout stderr := &cappedBuffer{limit: outputCap}
cmd.Stderr = &stderr cmd.Stdout = stdout
cmd.Stderr = stderr
if err := cmd.Run(); err != nil { if err := cmd.Run(); err != nil {
if errors.Is(ctx.Err(), context.DeadlineExceeded) {
return "", fmt.Errorf("tesseract: délai dépassé (%s): %w", tesseractTimeout, ctx.Err())
}
if errors.Is(ctx.Err(), context.Canceled) { if errors.Is(ctx.Err(), context.Canceled) {
return "", ctx.Err() return "", ctx.Err()
} }
@@ -41,24 +105,37 @@ func runTesseract(ctx context.Context, filePath, lang string) (string, error) {
} }
return "", errors.New("tesseract: " + msg) return "", errors.New("tesseract: " + msg)
} }
if stdout.truncated {
return "", fmt.Errorf("tesseract: sortie tronquée (> %d octets)", outputCap)
}
// stderr tronqué avec un run OK : le texte est complet, mais le diagnostic
// est perdu — on l'accepte sans échouer le job.
return strings.TrimSpace(stdout.String()), nil return strings.TrimSpace(stdout.String()), nil
} }
func extractPDFText(filePath string) (string, error) { func extractPDFText(ctx context.Context, filePath string) (string, error) {
f, r, err := pdf.Open(filePath) f, r, err := pdf.Open(filePath)
if err != nil { if err != nil {
return "", errors.New("pdf: " + err.Error()) return "", errors.New("pdf: " + err.Error())
} }
defer f.Close() defer f.Close()
if n := r.NumPage(); n > maxPDFPages {
return "", fmt.Errorf("pdf: %d pages > plafond %d (tronquer = perdre du texte)", n, maxPDFPages)
}
var builder strings.Builder var builder strings.Builder
for i := 1; i <= r.NumPage(); i++ { for i := 1; i <= r.NumPage(); i++ {
select {
case <-ctx.Done():
return "", fmt.Errorf("pdf: annulé page %d: %w", i, ctx.Err())
default:
}
p := r.Page(i) p := r.Page(i)
if p.V.IsNull() { if p.V.IsNull() {
continue return "", fmt.Errorf("pdf: page %d nulle", i)
} }
plain, err := p.GetPlainText(nil) plain, err := p.GetPlainText(nil)
if err != nil { if err != nil {
continue return "", fmt.Errorf("pdf: page %d illisible: %w", i, err)
} }
builder.WriteString(plain) builder.WriteString(plain)
builder.WriteString("\n") builder.WriteString("\n")
+52
View File
@@ -0,0 +1,52 @@
package ocr
import (
"strings"
"testing"
)
func TestValidTesseractLang(t *testing.T) {
valid := []string{"fra", "eng", "fra+eng", "de", "abcdefghijklmnopqrst"} // 20 chars
for _, lang := range valid {
if !validTesseractLang(lang) {
t.Errorf("langue %q : attendue valide", lang)
}
}
invalid := []string{
"", "e", "fra;rm -rf", "fra eng", "fra+eng --psm",
"FRA", "fra-eng", "fra/eng", "abcdefghijklmnopqrstu", // 21 chars
"fra\neng", "-l fra",
}
for _, lang := range invalid {
if validTesseractLang(lang) {
t.Errorf("langue %q : attendue invalide (injection -l)", lang)
}
}
}
func TestCappedBufferTruncation(t *testing.T) {
c := &cappedBuffer{limit: 8}
if _, err := c.Write([]byte("12345678")); err != nil {
t.Fatalf("write: %v", err)
}
if c.truncated {
t.Error("8 octets pour limite 8 : ne doit pas être tronqué")
}
if _, err := c.Write([]byte("9")); err != nil {
t.Fatalf("write: %v", err)
}
if !c.truncated {
t.Error("9 octets pour limite 8 : doit être marqué tronqué")
}
if c.String() != "12345678" {
t.Errorf("contenu = %q, attendu %q", c.String(), "12345678")
}
// Écriture massive d'un coup : bornée, jamais plus que `limit`.
big := &cappedBuffer{limit: 4}
if _, err := big.Write([]byte(strings.Repeat("x", 1<<20))); err != nil {
t.Fatalf("write: %v", err)
}
if !big.truncated || len(big.String()) != 4 {
t.Errorf("écriture 1 Mo limite 4 : tronqué=%v len=%d", big.truncated, len(big.String()))
}
}
+13 -1
View File
@@ -1,6 +1,10 @@
package api package api
import "github.com/gin-gonic/gin" import (
"log"
"github.com/gin-gonic/gin"
)
const NotImplementedCode = "NOT_IMPLEMENTED" const NotImplementedCode = "NOT_IMPLEMENTED"
@@ -22,6 +26,14 @@ func OKList(c *gin.Context, data any, page, pageSize, total int) {
} }
func Error(c *gin.Context, status int, code, message string) { func Error(c *gin.Context, status int, code, message string) {
// LOT 6 §5 : le client ne reçoit que l'enveloppe générique (code +
// message sans détail interne — jamais de err.Error() brut). Le détail
// va au log serveur pour le diagnostic.
path := ""
if c.Request != nil && c.Request.URL != nil {
path = c.Request.URL.Path
}
log.Printf("api error: status=%d code=%s message=%s path=%s", status, code, message, path)
c.JSON(status, gin.H{ c.JSON(status, gin.H{
"error": gin.H{"code": code, "message": message}, "error": gin.H{"code": code, "message": message},
}) })
+18 -4
View File
@@ -3,6 +3,7 @@ package auth
import ( import (
"crypto/sha256" "crypto/sha256"
"errors" "errors"
"regexp"
"time" "time"
"aidanwoods.dev/go-paseto" "aidanwoods.dev/go-paseto"
@@ -14,6 +15,8 @@ const TokenTTL = 7 * 24 * time.Hour
var ErrInvalidToken = errors.New("invalid token") var ErrInvalidToken = errors.New("invalid token")
var hex32Pattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
// Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant) // Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant)
// et le device (claim secondaire, porté mais NON autorisant seul). // et le device (claim secondaire, porté mais NON autorisant seul).
type Identity struct { type Identity struct {
@@ -39,29 +42,40 @@ func NewManager(secret string) (*Manager, error) {
// Issue émet un token lié à un utilisateur ET à un device. // Issue émet un token lié à un utilisateur ET à un device.
func (m *Manager) Issue(userID, deviceID string) (string, error) { func (m *Manager) Issue(userID, deviceID string) (string, error) {
token, _, err := m.IssueWithExpiry(userID, deviceID)
return token, err
}
// IssueWithExpiry émet un token et retourne son expiration réelle (le `exp`
// embarqué). Les appelants doivent exposer expiresAt, jamais le recalculer
// via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7).
func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, error) {
now := time.Now() now := time.Now()
expiresAt := now.Add(TokenTTL)
token := paseto.NewToken() token := paseto.NewToken()
token.SetIssuedAt(now) token.SetIssuedAt(now)
token.SetNotBefore(now) token.SetNotBefore(now)
token.SetExpiration(now.Add(TokenTTL)) token.SetExpiration(expiresAt)
token.SetSubject(userID) token.SetSubject(userID)
// v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable). // v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable).
token.SetString("device_id", deviceID) token.SetString("device_id", deviceID)
return token.V4Encrypt(m.key, nil), nil return token.V4Encrypt(m.key, nil), expiresAt, nil
} }
// Verify décode et contrôle le token, retourne l'identité (user + device). // Verify décode et contrôle le token, retourne l'identité (user + device).
// Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) — rejet
// sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK.
func (m *Manager) Verify(signed string) (Identity, error) { func (m *Manager) Verify(signed string) (Identity, error) {
parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil)
if err != nil { if err != nil {
return Identity{}, ErrInvalidToken return Identity{}, ErrInvalidToken
} }
userID, err := parsed.GetSubject() userID, err := parsed.GetSubject()
if err != nil || userID == "" { if err != nil || !hex32Pattern.MatchString(userID) {
return Identity{}, ErrInvalidToken return Identity{}, ErrInvalidToken
} }
deviceID, err := parsed.GetString("device_id") deviceID, err := parsed.GetString("device_id")
if err != nil || deviceID == "" { if err != nil || !hex32Pattern.MatchString(deviceID) {
return Identity{}, ErrInvalidToken return Identity{}, ErrInvalidToken
} }
return Identity{UserID: userID, DeviceID: deviceID}, nil return Identity{UserID: userID, DeviceID: deviceID}, nil
+60
View File
@@ -96,6 +96,44 @@ func TestVerifyRequiresDeviceClaim(t *testing.T) {
} }
} }
func TestVerifyRejectsNonHex32IDs(t *testing.T) {
m, _ := NewManager("test-secret")
issueWith := func(userID, deviceID string) string {
token := paseto.NewToken()
now := time.Now()
token.SetIssuedAt(now)
token.SetNotBefore(now)
token.SetExpiration(now.Add(TokenTTL))
token.SetSubject(userID)
token.SetString("device_id", deviceID)
return token.V4Encrypt(m.key, nil)
}
cases := map[string][2]string{
"subject vide": {"", testDeviceID},
"subject non-hex": {"not-hex-at-all-!!!!!!!!!!!!!!!!", testDeviceID},
"subject majuscules": {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", testDeviceID},
"subject trop court": {"abc123", testDeviceID},
"device vide": {testUserID, ""},
"device non-hex": {testUserID, "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"},
"device majuscules": {testUserID, "0123456789ABCDEF0123456789ABCDEF"},
"device trop long": {testUserID, testDeviceID + "00"},
"device avec tirets": {testUserID, "01234567-89ab-cdef-0123-456789abcdef"},
}
for name, ids := range cases {
signed := issueWith(ids[0], ids[1])
if _, err := m.Verify(signed); err == nil {
t.Errorf("%s: token accepté (user=%q device=%q), attendu rejet", name, ids[0], ids[1])
}
}
// Sanity : les IDs 32-hex valides passent toujours.
if _, err := m.Verify(issueWith(testUserID, testDeviceID)); err != nil {
t.Errorf("IDs valides rejetés: %v", err)
}
}
func TestIssueSetsExpiration(t *testing.T) { func TestIssueSetsExpiration(t *testing.T) {
m, _ := NewManager("test-secret") m, _ := NewManager("test-secret")
before := time.Now() before := time.Now()
@@ -118,3 +156,25 @@ func TestIssueSetsExpiration(t *testing.T) {
t.Errorf("expiration = %v, attendu ≈ now+%v (fenêtre [%v, %v])", exp, TokenTTL, lower, upper) t.Errorf("expiration = %v, attendu ≈ now+%v (fenêtre [%v, %v])", exp, TokenTTL, lower, upper)
} }
} }
func TestIssueWithExpiryMatchesTokenExp(t *testing.T) {
m, _ := NewManager("test-secret")
signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID)
if err != nil {
t.Fatalf("IssueWithExpiry: %v", err)
}
parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil)
if err != nil {
t.Fatalf("parse: %v", err)
}
exp, err := parsed.GetExpiration()
if err != nil {
t.Fatalf("GetExpiration: %v", err)
}
// L'expiresAt retourné doit être le exp embarqué (pas un Now()+TTL
// recalculé — cf. FEEDBACK A7). Comparaison à la seconde : le token
// sérialise sans lecture monotonique ni sous-seconde.
if exp.Unix() != expiresAt.Unix() {
t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp)
}
}
+25 -5
View File
@@ -30,12 +30,17 @@ var (
ErrMalformed = errors.New("malformed password hash") ErrMalformed = errors.New("malformed password hash")
) )
// dummyHash est un hash argon2id valide d'un mot de passe aléatoire fixe. // dummyHash est un hash argon2id valide d'un mot de passe aléatoire généré
// Il sert d'égalisation de timing : quand le username est inconnu, on vérifie // au boot. Il sert d'égalisation de timing : quand le username est inconnu,
// quand même contre ce hash pour que le délai de réponse soit identique à un // on vérifie quand même contre ce hash pour que le délai de réponse soit
// « mauvais mot de passe ». // identique à un « mauvais mot de passe ». Aléatoire par boot pour éviter
// toute préimage hardcodée (cf. FEEDBACK A1).
var dummyHash = func() string { var dummyHash = func() string {
h, err := Hash("vaultdrop-constantime-dummy") raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
panic(fmt.Sprintf("passwd: entropie dummy indisponible: %v", err))
}
h, err := Hash(string(raw))
if err != nil { if err != nil {
panic(fmt.Sprintf("passwd: impossible de pré-hacher le dummy: %v", err)) panic(fmt.Sprintf("passwd: impossible de pré-hacher le dummy: %v", err))
} }
@@ -75,6 +80,18 @@ func Verify(password, stored string) error {
if _, err := fmt.Sscanf(fields[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil { if _, err := fmt.Sscanf(fields[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
return ErrMalformed return ErrMalformed
} }
// Caps anti-DoS : un hash stocké compromis ne doit pas provoquer un
// OOM/CPU arbitraire au prochain login (cf. FEEDBACK §moyenne).
const (
maxMemory = 256 * 1024 // 256 MiB
maxTime = 10
maxThreads = 8
maxKeyLen = 128
maxSaltLen = 128
)
if memory <= 0 || memory > maxMemory || timeCost <= 0 || timeCost > maxTime || threads <= 0 || threads > maxThreads {
return ErrMalformed
}
salt, err := base64.RawStdEncoding.DecodeString(fields[4]) salt, err := base64.RawStdEncoding.DecodeString(fields[4])
if err != nil { if err != nil {
@@ -84,6 +101,9 @@ func Verify(password, stored string) error {
if err != nil { if err != nil {
return ErrMalformed return ErrMalformed
} }
if len(salt) == 0 || len(salt) > maxSaltLen || len(want) == 0 || len(want) > maxKeyLen {
return ErrMalformed
}
got := argon2.IDKey([]byte(password), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want))) got := argon2.IDKey([]byte(password), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want)))
if subtle.ConstantTimeCompare(got, want) != 1 { if subtle.ConstantTimeCompare(got, want) != 1 {
+14 -2
View File
@@ -33,10 +33,22 @@ func (d *Devices) Exists(deviceID string) (bool, error) {
// MarkUser mémorise le dernier utilisateur connecté sur ce device (INFORMATIF, // MarkUser mémorise le dernier utilisateur connecté sur ce device (INFORMATIF,
// jamais autorisant) et rafraîchit last_seen_at. Appelé au login. // jamais autorisant) et rafraîchit last_seen_at. Appelé au login.
// Device absent → ErrNotFound (le handler distingue la course
// Exists→MarkUser au lieu d'émettre un token pour un device fantôme).
func (d *Devices) MarkUser(deviceID, userID string) error { func (d *Devices) MarkUser(deviceID, userID string) error {
_, err := d.DB.Exec( result, err := d.DB.Exec(
`UPDATE devices SET user_id = $2, last_seen_at = NOW() WHERE device_id = $1`, `UPDATE devices SET user_id = $2, last_seen_at = NOW() WHERE device_id = $1`,
deviceID, userID, deviceID, userID,
) )
return err if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
} }
+11 -1
View File
@@ -1,9 +1,10 @@
package repository package repository
import ( import (
"errors"
"testing" "testing"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
) )
func newTestDevices(t *testing.T) *Devices { func newTestDevices(t *testing.T) *Devices {
@@ -71,3 +72,12 @@ func TestDevicesMarkUser(t *testing.T) {
t.Errorf("user_id mémorisé = %q, attendu %q", storedUser, userID) t.Errorf("user_id mémorisé = %q, attendu %q", storedUser, userID)
} }
} }
func TestDevicesMarkUserUnknownDevice(t *testing.T) {
d := newTestDevices(t)
// Device jamais enregistré → ErrNotFound (pas de UPDATE silencieux à
// 0 ligne) : le login mappe ce cas en 401 au lieu d'émettre un token.
if err := d.MarkUser(NewID(), NewID()); !errors.Is(err, ErrNotFound) {
t.Errorf("MarkUser device inconnu: attendu ErrNotFound, got %v", err)
}
}
+94 -8
View File
@@ -3,6 +3,7 @@ package repository
import ( import (
"database/sql" "database/sql"
"errors" "errors"
"time"
) )
// OcrJobRow maps ocr_jobs. // OcrJobRow maps ocr_jobs.
@@ -18,6 +19,15 @@ type OcrJobRow struct {
// ErrJobNotFound marks an OCR job absent or owned by another device. // ErrJobNotFound marks an OCR job absent or owned by another device.
var ErrJobNotFound = errors.New("ocr job not found") var ErrJobNotFound = errors.New("ocr job not found")
// ErrNoQueuedJobs marks an OCR queue drained (no job to claim).
var ErrNoQueuedJobs = errors.New("no queued ocr jobs")
// ErrJobStateConflict marks a guarded transition attempted from an
// unexpected state (double Complete, Fail of a non-processing job,
// TouchProcessing of a non-queued job). Terminal states are sticky:
// a second transition never overwrites the first.
var ErrJobStateConflict = errors.New("ocr job state conflict")
type OcrJobs struct{ DB *sql.DB } type OcrJobs struct{ DB *sql.DB }
func (o *OcrJobs) Create(jobID, deviceID, fileID string) error { func (o *OcrJobs) Create(jobID, deviceID, fileID string) error {
@@ -54,28 +64,104 @@ func (o *OcrJobs) Get(deviceID, jobID string) (OcrJobRow, error) {
} }
func (o *OcrJobs) TouchProcessing(deviceID, jobID string) error { func (o *OcrJobs) TouchProcessing(deviceID, jobID string) error {
_, err := o.DB.Exec( res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'processing', started_at = NOW() `UPDATE ocr_jobs SET status = 'processing', started_at = NOW()
WHERE job_id = $1 AND device_id = $2 AND status = 'queued'`, WHERE job_id = $1 AND device_id = $2 AND status = 'queued'`,
jobID, deviceID, jobID, deviceID,
) )
return err if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrJobStateConflict
}
return nil
}
// ClaimNext atomically picks the oldest queued job (FIFO) and moves it to
// `processing`. Safe for concurrent workers: `FOR UPDATE SKIP LOCKED` blocks
// the row as part of the same statement. Empty queue → ErrNoQueuedJobs.
func (o *OcrJobs) ClaimNext() (OcrJobRow, error) {
var row OcrJobRow
err := o.DB.QueryRow(
`WITH next AS (
SELECT job_id FROM ocr_jobs
WHERE status = 'queued'
ORDER BY created_at, job_id
LIMIT 1
FOR UPDATE SKIP LOCKED
)
UPDATE ocr_jobs
SET status = 'processing', started_at = NOW()
FROM next
WHERE ocr_jobs.job_id = next.job_id
RETURNING ocr_jobs.job_id, ocr_jobs.file_id, ocr_jobs.device_id, ocr_jobs.status`,
).Scan(&row.ID, &row.FileID, &row.DeviceID, &row.Status)
if err == sql.ErrNoRows {
return OcrJobRow{}, ErrNoQueuedJobs
}
if err != nil {
return OcrJobRow{}, err
}
return row, nil
}
// ResetStaleProcessing requeues jobs stuck in `processing` (worker crash /
// processus redémarré) et plus vieux que `olderThan`. Retourne le nb de jobs
// requeued. La comparaison utilise l'horloge DB (NOW(), pas time.Now() du
// process) pour rester correcte même si les horloges divergent. Les jobs sans
// `started_at` (claim sans timestamp, anomalie) sont aussi requeued.
func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) {
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'queued', started_at = NULL
WHERE status = 'processing'
AND (started_at IS NULL OR started_at < NOW() - ($1::bigint * INTERVAL '1 millisecond'))`,
olderThan.Milliseconds(),
)
if err != nil {
return 0, err
}
return res.RowsAffected()
} }
func (o *OcrJobs) Complete(deviceID, jobID, text string) error { func (o *OcrJobs) Complete(deviceID, jobID, text string) error {
_, err := o.DB.Exec( res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'done', text = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW() `UPDATE ocr_jobs SET status = 'done', text = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW()
WHERE job_id = $1 AND device_id = $2`, WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
jobID, deviceID, text, jobID, deviceID, text,
) )
return err if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrJobStateConflict
}
return nil
} }
func (o *OcrJobs) Fail(deviceID, jobID, message string) error { func (o *OcrJobs) Fail(deviceID, jobID, message string) error {
_, err := o.DB.Exec( res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'failed', error = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW() `UPDATE ocr_jobs SET status = 'failed', error = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW()
WHERE job_id = $1 AND device_id = $2`, WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
jobID, deviceID, message, jobID, deviceID, message,
) )
return err if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrJobStateConflict
}
return nil
} }
+180 -1
View File
@@ -3,8 +3,9 @@ package repository
import ( import (
"errors" "errors"
"testing" "testing"
"time"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
) )
func newTestRepo(t *testing.T) *Repository { func newTestRepo(t *testing.T) *Repository {
@@ -66,6 +67,10 @@ func TestOcrJobsFail(t *testing.T) {
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil { if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
t.Fatalf("create: %v", err) t.Fatalf("create: %v", err)
} }
// Fail n'est valide que depuis `processing` (transition gardée).
if err := repo.OcrJobs.TouchProcessing(deviceID, jobID); err != nil {
t.Fatalf("touch processing: %v", err)
}
if err := repo.OcrJobs.Fail(deviceID, jobID, "tesseract exploded"); err != nil { if err := repo.OcrJobs.Fail(deviceID, jobID, "tesseract exploded"); err != nil {
t.Fatalf("fail: %v", err) t.Fatalf("fail: %v", err)
} }
@@ -75,6 +80,71 @@ func TestOcrJobsFail(t *testing.T) {
} }
} }
func TestOcrJobsGuardedTransitions(t *testing.T) {
repo, _, deviceID, fileID := seedOcrJobFixture(t)
newJob := func(t *testing.T) string {
t.Helper()
jobID := NewID()
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
t.Fatalf("create: %v", err)
}
return jobID
}
// Fail depuis `queued` → conflit, le job reste queued.
queued := newJob(t)
if err := repo.OcrJobs.Fail(deviceID, queued, "boom"); !errors.Is(err, ErrJobStateConflict) {
t.Errorf("fail depuis queued : attendu ErrJobStateConflict, got %v", err)
}
if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Status != "queued" {
t.Errorf("fail depuis queued : status = %q, attendu queued", row.Status)
}
// Complete depuis `queued` → conflit.
if err := repo.OcrJobs.Complete(deviceID, queued, "x"); !errors.Is(err, ErrJobStateConflict) {
t.Errorf("complete depuis queued : attendu ErrJobStateConflict, got %v", err)
}
// Double TouchProcessing → conflit.
if err := repo.OcrJobs.TouchProcessing(deviceID, queued); err != nil {
t.Fatalf("touch processing: %v", err)
}
if err := repo.OcrJobs.TouchProcessing(deviceID, queued); !errors.Is(err, ErrJobStateConflict) {
t.Errorf("double touch : attendu ErrJobStateConflict, got %v", err)
}
// Double Complete → le premier gagne, le second est un conflit.
if err := repo.OcrJobs.Complete(deviceID, queued, "FIRST"); err != nil {
t.Fatalf("complete: %v", err)
}
if err := repo.OcrJobs.Complete(deviceID, queued, "SECOND"); !errors.Is(err, ErrJobStateConflict) {
t.Errorf("double complete : attendu ErrJobStateConflict, got %v", err)
}
if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Text == nil || *row.Text != "FIRST" {
t.Errorf("double complete : texte = %+v, attendu FIRST", row.Text)
}
// Fail après Complete → conflit, le statut `done` est collant.
if err := repo.OcrJobs.Fail(deviceID, queued, "late"); !errors.Is(err, ErrJobStateConflict) {
t.Errorf("fail après done : attendu ErrJobStateConflict, got %v", err)
}
if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Status != "done" {
t.Errorf("fail après done : status = %q, attendu done", row.Status)
}
// Complete après Fail → conflit.
failed := newJob(t)
if err := repo.OcrJobs.TouchProcessing(deviceID, failed); err != nil {
t.Fatalf("touch processing: %v", err)
}
if err := repo.OcrJobs.Fail(deviceID, failed, "boom"); err != nil {
t.Fatalf("fail: %v", err)
}
if err := repo.OcrJobs.Complete(deviceID, failed, "late"); !errors.Is(err, ErrJobStateConflict) {
t.Errorf("complete après failed : attendu ErrJobStateConflict, got %v", err)
}
}
func TestOcrJobsGetScopedByDevice(t *testing.T) { func TestOcrJobsGetScopedByDevice(t *testing.T) {
repo, _, deviceID, fileID := seedOcrJobFixture(t) repo, _, deviceID, fileID := seedOcrJobFixture(t)
jobID := NewID() jobID := NewID()
@@ -90,3 +160,112 @@ func TestOcrJobsGetScopedByDevice(t *testing.T) {
t.Errorf("get par un autre device : attendu ErrJobNotFound, got %v", err) t.Errorf("get par un autre device : attendu ErrJobNotFound, got %v", err)
} }
} }
func TestOcrJobsClaimNextFifo(t *testing.T) {
repo, _, deviceID, fileID := seedOcrJobFixture(t)
var jobIDs []string
for i := 0; i < 3; i++ {
jobID := NewID()
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
t.Fatalf("create %d: %v", i, err)
}
jobIDs = append(jobIDs, jobID)
}
for i, want := range jobIDs {
row, err := repo.OcrJobs.ClaimNext()
if err != nil {
t.Fatalf("claim %d: %v", i, err)
}
if row.ID != want {
t.Errorf("claim %d = %q, attendu %q (FIFO)", i, row.ID, want)
}
if row.Status != "processing" {
t.Errorf("claim %d status = %q, attendu processing", i, row.Status)
}
}
if _, err := repo.OcrJobs.ClaimNext(); !errors.Is(err, ErrNoQueuedJobs) {
t.Errorf("queue vide : attendu ErrNoQueuedJobs, got %v", err)
}
}
func TestOcrJobsClaimNextSkipsProcessingAndDone(t *testing.T) {
repo, _, deviceID, fileID := seedOcrJobFixture(t)
job1 := NewID()
job2 := NewID()
if err := repo.OcrJobs.Create(job1, deviceID, fileID); err != nil {
t.Fatalf("create job1: %v", err)
}
if err := repo.OcrJobs.Create(job2, deviceID, fileID); err != nil {
t.Fatalf("create job2: %v", err)
}
if err := repo.OcrJobs.TouchProcessing(deviceID, job2); err != nil {
t.Fatalf("touch job2 processing: %v", err)
}
row, err := repo.OcrJobs.ClaimNext()
if err != nil {
t.Fatalf("claim: %v", err)
}
if row.ID != job1 {
t.Errorf("claim = %q, attendu job1 %q", row.ID, job1)
}
}
func TestOcrJobsResetStaleProcessing(t *testing.T) {
repo, _, deviceID, fileID := seedOcrJobFixture(t)
jobID := NewID()
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
t.Fatalf("create: %v", err)
}
if err := repo.OcrJobs.TouchProcessing(deviceID, jobID); err != nil {
t.Fatalf("touch processing: %v", err)
}
// Started_at = NOW : pas encore stale → aucun requeue.
if n, err := repo.OcrJobs.ResetStaleProcessing(time.Minute); err != nil {
t.Fatalf("reset: %v", err)
} else if n != 0 {
t.Errorf("reset récent : attendu 0, got %d", n)
}
// Vieillit le started_at puis re-reset → 1 requeue.
if _, err := repo.OcrJobs.DB.Exec(`UPDATE ocr_jobs SET started_at = NOW() - interval '2 minutes' WHERE job_id = $1`, jobID); err != nil {
t.Fatalf("vieillir started_at: %v", err)
}
if n, err := repo.OcrJobs.ResetStaleProcessing(time.Minute); err != nil {
t.Fatalf("reset stale: %v", err)
} else if n != 1 {
t.Errorf("reset stale : attendu 1, got %d", n)
}
row, err := repo.OcrJobs.Get(deviceID, jobID)
if err != nil {
t.Fatalf("get: %v", err)
}
if row.Status != "queued" {
t.Errorf("status après reset = %q, attendu queued", row.Status)
}
}
func TestOcrJobsResetStaleProcessingNullStartedAt(t *testing.T) {
repo, _, deviceID, fileID := seedOcrJobFixture(t)
jobID := NewID()
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
t.Fatalf("create: %v", err)
}
// Job passé en `processing` sans `started_at` (anomalie de claim) → stale.
if _, err := repo.OcrJobs.DB.Exec(
`UPDATE ocr_jobs SET status = 'processing', started_at = NULL WHERE job_id = $1`, jobID); err != nil {
t.Fatalf("forcer processing sans started_at: %v", err)
}
if n, err := repo.OcrJobs.ResetStaleProcessing(time.Minute); err != nil {
t.Fatalf("reset: %v", err)
} else if n != 1 {
t.Errorf("reset started_at NULL : attendu 1, got %d", n)
}
if row, _ := repo.OcrJobs.Get(deviceID, jobID); row.Status != "queued" {
t.Errorf("status après reset = %q, attendu queued", row.Status)
}
}
+162 -4
View File
@@ -1,7 +1,9 @@
package repository package repository
import ( import (
"crypto/sha256"
"database/sql" "database/sql"
"encoding/hex"
"encoding/json" "encoding/json"
"errors" "errors"
"regexp" "regexp"
@@ -16,9 +18,26 @@ type Operations struct {
DB *sql.DB DB *sql.DB
} }
// Statuts de la trace outbox (CHECK status IN ('applied','failed'), 000004).
// 'failed' = brouillon claimé pas encore confirmé (ou apply en échec) ;
// 'applied' = effet durable confirmé.
const (
OpStatusApplied = "applied"
OpStatusFailed = "failed"
)
// ErrInvalidOperationID is returned when operation_id is not 32 lowercase hex. // ErrInvalidOperationID is returned when operation_id is not 32 lowercase hex.
var ErrInvalidOperationID = errors.New("operation_id must be 32 lowercase hex chars") var ErrInvalidOperationID = errors.New("operation_id must be 32 lowercase hex chars")
// ErrInvalidPayload is returned when the trace payload is not valid JSON.
// Le service le mappe en INVALID_REQUEST (faute client, message statique sûr).
var ErrInvalidPayload = errors.New("invalid payload JSON")
// ErrPayloadMismatch is returned when an operation is replayed under the same
// (device_id, operation_id) with a different payload (cf. A9). The replay
// must halt in INVALID_REQUEST, never skip silently.
var ErrPayloadMismatch = errors.New("operation replayed with different payload")
// Applied reports whether the operation was already processed for this device. // Applied reports whether the operation was already processed for this device.
func (o *Operations) Applied(deviceID, operationID string) (bool, error) { func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
var exists int var exists int
@@ -32,20 +51,157 @@ func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
return err == nil, err return err == nil, err
} }
// StoredOp is the persisted trace of an applied operation (replay compare).
type StoredOp struct {
OpType string
ResourceID string
Payload []byte
Status string
PayloadHash string // "" = trace héritée pré-000013 (hash recalculé depuis Payload)
}
// Get returns the stored trace for (device, operation), or sql.ErrNoRows.
func (o *Operations) Get(deviceID, operationID string) (StoredOp, error) {
var op StoredOp
var resourceID sql.NullString
var payloadHash sql.NullString
var payload []byte
err := o.DB.QueryRow(
`SELECT op_type, resource_id, COALESCE(payload::text, '{}'), status, payload_hash
FROM operations WHERE device_id = $1 AND operation_id = $2`,
deviceID, operationID,
).Scan(&op.OpType, &resourceID, &payload, &op.Status, &payloadHash)
if err != nil {
return StoredOp{}, err
}
if resourceID.Valid {
op.ResourceID = resourceID.String
}
if payloadHash.Valid {
op.PayloadHash = payloadHash.String
}
op.Payload = payload
return op, nil
}
// Claim atomically takes ownership of an operation slot for this device
// (#7 : sérialisation des batches concurrents sur la contrainte
// UNIQUE(device_id, operation_id)). Premier appelant → claimed=true, la ligne
// est insérée en status='failed' (brouillon) avec le hash du payload ; le
// perdant du conflit (claimed=false) suit le chemin rejeu (comparer via Get).
// Après apply réussi, l'appelant promeut la ligne via MarkApplied ; en cas
// d'échec d'apply, la ligne reste 'failed' (rejouable à payload identique).
func (o *Operations) Claim(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) (bool, error) {
if !operationIDPattern.MatchString(operationID) {
return false, ErrInvalidOperationID
}
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
return false, ErrInvalidPayload
}
var refTypeValue any
if refType != "" {
refTypeValue = refType
}
res, err := o.DB.Exec(
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'failed')
ON CONFLICT (device_id, operation_id) DO NOTHING`,
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload),
)
if err != nil {
return false, err
}
affected, err := res.RowsAffected()
if err != nil {
return false, err
}
return affected == 1, nil
}
// MarkApplied promotes a claimed ('failed') trace row to 'applied' once the
// operation effect is durable. Best-effort : l'échec est remonté pour que le
// batch retourne applied:i explicite (rejouable, pas 500 nu).
func (o *Operations) MarkApplied(deviceID, operationID string) error {
res, err := o.DB.Exec(
`UPDATE operations SET status = 'applied'
WHERE device_id = $1 AND operation_id = $2 AND status = 'failed'`,
deviceID, operationID,
)
if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
// Déjà promue (rejeu concurrent) ou ligne absente : pas d'erreur,
// l'idempotence est portée par la contrainte d'unicité.
return nil
}
return nil
}
// MatchesReplay reports whether an incoming operation matches the stored
// trace: same op type, same resource, same canonical payload hash. Legacy
// rows (payload_hash NULL, pré-000013) comparent le hash recalculé depuis le
// payload stocké. Mismatch → ErrPayloadMismatch (wrappable via errors.Is).
func (op StoredOp) MatchesReplay(opType, resourceID string, payload []byte) error {
if op.OpType != opType || op.ResourceID != resourceID {
return ErrPayloadMismatch
}
want := CanonicalPayloadHash(payload)
got := op.PayloadHash
if got == "" {
got = CanonicalPayloadHash(op.Payload)
}
if got != want {
return ErrPayloadMismatch
}
return nil
}
// CanonicalPayloadHash is sha256-hex of the canonical payload form: empty /
// "null" → {}, sinon round-trip JSON (clés triées, espaces neutralisés) pour
// que deux sérialisations du même objet donnent le même hash.
func CanonicalPayloadHash(payload []byte) string {
sum := sha256.Sum256(canonicalPayloadBytes(payload))
return hex.EncodeToString(sum[:])
}
func canonicalPayloadBytes(payload []byte) []byte {
if len(payload) == 0 || string(payload) == "null" {
return []byte(`{}`)
}
var v any
if err := json.Unmarshal(payload, &v); err != nil {
return []byte(`{}`)
}
out, err := json.Marshal(v)
if err != nil {
return []byte(`{}`)
}
return out
}
// Record stores an applied operation trace (idempotent on replay). // Record stores an applied operation trace (idempotent on replay).
// Le hash canonique du payload est persisté (000013, cf. A9) ; status='applied'.
func (o *Operations) Record(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) error { func (o *Operations) Record(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) error {
if !operationIDPattern.MatchString(operationID) { if !operationIDPattern.MatchString(operationID) {
return ErrInvalidOperationID return ErrInvalidOperationID
} }
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
return ErrInvalidPayload
}
var refTypeValue any var refTypeValue any
if refType != "" { if refType != "" {
refTypeValue = refType refTypeValue = refType
} }
_, err := o.DB.Exec( _, err := o.DB.Exec(
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload) `INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status)
VALUES ($1, $2, $3, $4, $5, $6, $7) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'applied')
ON CONFLICT (device_id, operation_id) DO NOTHING`, ON CONFLICT (device_id, operation_id) DO NOTHING`,
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload),
) )
return err return err
} }
@@ -62,7 +218,9 @@ func jsonBytes(payload []byte) any {
return []byte(`{}`) return []byte(`{}`)
} }
if !json.Valid(payload) { if !json.Valid(payload) {
return []byte(`{}`) // Trace infidèle refusée (cf. A15) : l'appelant doit rejeter en amont ;
// ici on ne normalise plus silencieusement vers {}.
return nil
} }
return payload return payload
} }
+121 -14
View File
@@ -1,11 +1,10 @@
package repository package repository
import ( import (
"encoding/json"
"errors" "errors"
"testing" "testing"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
) )
func newTestOperations(t *testing.T) (*Operations, *Devices) { func newTestOperations(t *testing.T) (*Operations, *Devices) {
@@ -66,7 +65,7 @@ func TestOperationsRecordRejectsInvalidOperationID(t *testing.T) {
} }
} }
func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) { func TestOperationsRecordRejectsInvalidPayload(t *testing.T) {
o, devices := newTestOperations(t) o, devices := newTestOperations(t)
deviceID := NewID() deviceID := NewID()
if err := devices.Upsert(deviceID); err != nil { if err := devices.Upsert(deviceID); err != nil {
@@ -74,20 +73,128 @@ func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) {
} }
opID := NewID() opID := NewID()
// Un payload non-JSON ne doit pas faire échouer la trace (jsonBytes → {}). // Un payload non-JSON est refusé (pas de normalisation silencieuse vers {}) :
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err != nil { // l'appelant (service) doit rejeter en amont en INVALID_REQUEST.
t.Fatalf("record: %v", err) if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err == nil {
t.Error("payload non-JSON : erreur attendue, got nil")
} }
if applied, _ := o.Applied(deviceID, opID); applied {
t.Error("record refusé : l'op ne doit pas être tracée")
}
}
func TestOperationsRecordStoresPayloadHash(t *testing.T) {
o, devices := newTestOperations(t)
deviceID := NewID()
if err := devices.Upsert(deviceID); err != nil {
t.Fatalf("register device: %v", err)
}
opID := NewID()
payload := []byte(`{"name":"x"}`)
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), payload); err != nil {
t.Fatalf("record: %v", err)
}
stored, err := o.Get(deviceID, opID)
if err != nil {
t.Fatalf("get: %v", err)
}
if stored.Status != OpStatusApplied {
t.Errorf("status = %q, attendu %q", stored.Status, OpStatusApplied)
}
want := CanonicalPayloadHash(payload)
if stored.PayloadHash != want {
t.Errorf("payload_hash = %q, attendu %q", stored.PayloadHash, want)
}
if len(stored.PayloadHash) != 64 {
t.Errorf("payload_hash attendu 64-hex, got %q", stored.PayloadHash)
}
}
func TestOperationsClaimAndMarkApplied(t *testing.T) {
o, devices := newTestOperations(t)
deviceID := NewID()
if err := devices.Upsert(deviceID); err != nil {
t.Fatalf("register device: %v", err)
}
var stored string opID := NewID()
if err := o.DB.QueryRow(`SELECT payload::text FROM operations WHERE device_id = $1 AND operation_id = $2`, deviceID, opID).Scan(&stored); err != nil { payload := []byte(`{"name":"x"}`)
t.Fatalf("read payload: %v", err) // Premier claim → pris.
claimed, err := o.Claim(deviceID, opID, "create_resource", "resource", nil, NewID(), payload)
if err != nil || !claimed {
t.Fatalf("claim 1: claimed=%v err=%v", claimed, err)
}
// La trace brouillon est en status failed (pas encore confirmée).
stored, err := o.Get(deviceID, opID)
if err != nil {
t.Fatalf("get: %v", err)
}
if stored.Status != OpStatusFailed {
t.Errorf("status après claim = %q, attendu %q", stored.Status, OpStatusFailed)
}
// Second claim (batch concurrent) → perdu, chemin rejeu.
claimed, err = o.Claim(deviceID, opID, "create_resource", "resource", nil, NewID(), payload)
if err != nil || claimed {
t.Fatalf("claim 2: claimed=%v err=%v", claimed, err)
}
// Promotion après apply réussi.
if err := o.MarkApplied(deviceID, opID); err != nil {
t.Fatalf("mark applied: %v", err)
}
stored, err = o.Get(deviceID, opID)
if err != nil {
t.Fatalf("get 2: %v", err)
}
if stored.Status != OpStatusApplied {
t.Errorf("status après promote = %q, attendu %q", stored.Status, OpStatusApplied)
}
// MarkApplied idempotent (re-promote sans effet).
if err := o.MarkApplied(deviceID, opID); err != nil {
t.Errorf("re-promote: %v", err)
}
}
func TestStoredOpMatchesReplay(t *testing.T) {
o, devices := newTestOperations(t)
deviceID := NewID()
if err := devices.Upsert(deviceID); err != nil {
t.Fatalf("register device: %v", err)
}
opID := NewID()
resID := NewID()
payload := []byte(`{"name":"x"}`)
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, resID, payload); err != nil {
t.Fatalf("record: %v", err)
}
stored, err := o.Get(deviceID, opID)
if err != nil {
t.Fatalf("get: %v", err)
}
// Identique (espaces neutres via hash canonique) → match.
if err := stored.MatchesReplay("create_resource", resID, []byte("{ \"name\" : \"x\" }")); err != nil {
t.Errorf("rejeu identique: %v", err)
}
// Payload muté → ErrPayloadMismatch.
if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"y"}`)); !errors.Is(err, ErrPayloadMismatch) {
t.Errorf("payload muté : attendu ErrPayloadMismatch, got %v", err)
}
// Type muté → ErrPayloadMismatch.
if err := stored.MatchesReplay("delete_resource", resID, payload); !errors.Is(err, ErrPayloadMismatch) {
t.Errorf("type muté : attendu ErrPayloadMismatch, got %v", err)
}
// Ressource mutée → ErrPayloadMismatch.
if err := stored.MatchesReplay("create_resource", NewID(), payload); !errors.Is(err, ErrPayloadMismatch) {
t.Errorf("ressource mutée : attendu ErrPayloadMismatch, got %v", err)
} }
var parsed any // Ligne héritée sans payload_hash (pré-000013) : hash recalculé depuis
if err := json.Unmarshal([]byte(stored), &parsed); err != nil { // le payload stocké → match quand identique.
t.Fatalf("payload stocké invalide: %q", stored) stored.PayloadHash = ""
if err := stored.MatchesReplay("create_resource", resID, payload); err != nil {
t.Errorf("ligne héritée identique: %v", err)
} }
if stored != "{}" { if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"z"}`)); !errors.Is(err, ErrPayloadMismatch) {
t.Errorf("payload normalisé attendu {}, got %q", stored) t.Errorf("ligne héritée mutée : attendu ErrPayloadMismatch, got %v", err)
} }
} }
+186 -50
View File
@@ -20,12 +20,22 @@ var ErrNameConflict = errors.New("name conflict")
// NewID returns an opaque lowercase 32-hex identifier (charset ^[0-9a-f]{32}$), // NewID returns an opaque lowercase 32-hex identifier (charset ^[0-9a-f]{32}$),
// mirroring the mobile's lower(hex(randomblob(16))). Never a UUID. // mirroring the mobile's lower(hex(randomblob(16))). Never a UUID.
// Panics on entropy failure (legacy) — prefer NewIDErr for new code.
func NewID() string { func NewID() string {
buf := make([]byte, 16) id, err := NewIDErr()
if _, err := rand.Read(buf); err != nil { if err != nil {
panic(fmt.Sprintf("crypto/rand failed: %v", err)) panic(fmt.Sprintf("crypto/rand failed: %v", err))
} }
return hex.EncodeToString(buf) return id
}
// NewIDErr is the non-panicking variant (cf. FEEDBACK A5).
func NewIDErr() (string, error) {
buf := make([]byte, 16)
if _, err := rand.Read(buf); err != nil {
return "", fmt.Errorf("crypto/rand failed: %w", err)
}
return hex.EncodeToString(buf), nil
} }
func isUniqueViolation(err error) bool { func isUniqueViolation(err error) bool {
@@ -33,6 +43,14 @@ func isUniqueViolation(err error) bool {
return errors.As(err, &pqErr) && pqErr.Code == "23505" return errors.As(err, &pqErr) && pqErr.Code == "23505"
} }
// isForeignKeyViolation reports a Postgres FK violation (23503). Une
// violation de FK parent (dossier cible disparu en course) est mappée vers
// ErrNotFound — cible inexistante — plutôt que de fuir en 500.
func isForeignKeyViolation(err error) bool {
var pqErr *pq.Error
return errors.As(err, &pqErr) && pqErr.Code == "23503"
}
type FileRow struct { type FileRow struct {
ID string ID string
Name string Name string
@@ -41,6 +59,7 @@ type FileRow struct {
FolderID string FolderID string
CreatedAt time.Time CreatedAt time.Time
UpdatedAt time.Time UpdatedAt time.Time
OcrText string
} }
type FolderRow struct { type FolderRow struct {
@@ -107,42 +126,39 @@ const grantedCTE = `
AND r.deleted_at IS NULL AND g.depth < 100 AND r.deleted_at IS NULL AND g.depth < 100
)` )`
func (r *Resources) folderExists(ownerID, folderID string) (bool, error) { // insert persiste une ligne file/folder avec parent-check ATOMIQUE
var exists int // (single-statement INSERT...SELECT) : le dossier parent (quand non vide)
err := r.DB.QueryRow( // doit exister, appartenir au même owner, être un folder non supprimé —
`SELECT 1 FROM resources // sinon ErrNotFound. L'ancien SELECT-then-INSERT (TOCTOU : parent supprimé
WHERE resource_id = $1 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL`, // entre check et insert → FK 500) est remplacé ; une violation FK résiduelle
folderID, ownerID, // (course) est mappée vers ErrNotFound, jamais 500.
).Scan(&exists)
if err == sql.ErrNoRows {
return false, nil
}
return err == nil, err
}
func (r *Resources) insert(ownerID, id, name, parentResourceID, resourceType string, size int64, mimeType, extension *string) error { func (r *Resources) insert(ownerID, id, name, parentResourceID, resourceType string, size int64, mimeType, extension *string) error {
if parentResourceID != "" { result, err := r.DB.Exec(
ok, err := r.folderExists(ownerID, parentResourceID)
if err != nil {
return err
}
if !ok {
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
}
}
var parentID any
if parentResourceID != "" {
parentID = parentResourceID
}
_, err := r.DB.Exec(
`INSERT INTO resources (resource_id, type, name, parent_id, user_id, size_bytes, mime_type, extension) `INSERT INTO resources (resource_id, type, name, parent_id, user_id, size_bytes, mime_type, extension)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, SELECT $1, $2, $3, NULLIF($4, ''), $5, $6, $7, $8
id, resourceType, name, parentID, ownerID, size, mimeType, extension, WHERE $4 = '' OR EXISTS (
SELECT 1 FROM resources
WHERE resource_id = $4 AND user_id = $5 AND type = 'folder' AND deleted_at IS NULL
)`,
id, resourceType, name, parentResourceID, ownerID, size, mimeType, extension,
) )
if isUniqueViolation(err) { if isUniqueViolation(err) {
return ErrNameConflict return ErrNameConflict
} }
return err if isForeignKeyViolation(err) {
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
}
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
}
return nil
} }
// InsertFile persists a file metadata row for the owner device. The parent // InsertFile persists a file metadata row for the owner device. The parent
@@ -156,11 +172,11 @@ func (r *Resources) InsertFolder(ownerID, id, name, parentResourceID string) err
return r.insert(ownerID, id, name, parentResourceID, "folder", 0, nil, nil) return r.insert(ownerID, id, name, parentResourceID, "folder", 0, nil, nil)
} }
const fileColumns = `resource_id, name, size_bytes, COALESCE(mime_type, ''), COALESCE(parent_id, ''), created_at, updated_at` const fileColumns = `resource_id, name, size_bytes, COALESCE(mime_type, ''), COALESCE(parent_id, ''), created_at, updated_at, COALESCE(ocr_text, '')`
func (r *Resources) scanFile(scan func(...any) error) (FileRow, error) { func (r *Resources) scanFile(scan func(...any) error) (FileRow, error) {
var row FileRow var row FileRow
err := scan(&row.ID, &row.Name, &row.Size, &row.MimeType, &row.FolderID, &row.CreatedAt, &row.UpdatedAt) err := scan(&row.ID, &row.Name, &row.Size, &row.MimeType, &row.FolderID, &row.CreatedAt, &row.UpdatedAt, &row.OcrText)
return row, err return row, err
} }
@@ -254,6 +270,41 @@ func (r *Resources) GetFileVisible(userID, resourceID string) (FileRow, error) {
return file, err return file, err
} }
// GetResourceOwner returns the owning user_id of any resource (file or folder).
// No-rows → ErrNotFound.
func (r *Resources) GetResourceOwner(resourceID string) (string, error) {
var ownerID string
err := r.DB.QueryRow(
`SELECT user_id FROM resources
WHERE resource_id = $1 AND deleted_at IS NULL`,
resourceID,
).Scan(&ownerID)
if errors.Is(err, sql.ErrNoRows) {
return "", ErrNotFound
}
return ownerID, err
}
// GetParentID returns the parent_id ('""' si racine) d'une ressource non
// supprimée. No-rows → ErrNotFound. Sert au check de cycle des moves.
func (r *Resources) GetParentID(resourceID string) (string, error) {
var parent sql.NullString
err := r.DB.QueryRow(
`SELECT parent_id FROM resources WHERE resource_id = $1 AND deleted_at IS NULL`,
resourceID,
).Scan(&parent)
if errors.Is(err, sql.ErrNoRows) {
return "", ErrNotFound
}
if err != nil {
return "", err
}
if !parent.Valid {
return "", nil
}
return parent.String, nil
}
// DeleteFile soft-deletes the file (deleted_at), returning its id. // DeleteFile soft-deletes the file (deleted_at), returning its id.
func (r *Resources) DeleteFile(ownerID, resourceID string) (string, error) { func (r *Resources) DeleteFile(ownerID, resourceID string) (string, error) {
result, err := r.DB.Exec( result, err := r.DB.Exec(
@@ -353,26 +404,28 @@ func (r *Resources) GetFolder(ownerID, resourceID string) (FolderRow, error) {
return row, err return row, err
} }
// MoveResource sets parent_id (root when parentResourceID empty). The target // MoveResource sets parent_id (root when parentResourceID empty) avec
// folder must exist and belong to the owner. Absent source is a no-op. // parent-check ATOMIQUE (single-statement) : la cible doit exister,
// appartenir au même owner, être un folder non supprimé. Source absente /
// non-owned OU cible absente → ErrNotFound (même code : le choix A8
// move-non-owned → NOT_FOUND est appliqué ici, cf. LOT 3 pour la doc
// sync). Violation FK résiduelle (course) → ErrNotFound, jamais 500.
func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) error { func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) error {
if parentResourceID != "" {
if _, err := r.GetFolder(ownerID, parentResourceID); err != nil {
return err
}
}
var parentID any
if parentResourceID != "" {
parentID = parentResourceID
}
result, err := r.DB.Exec( result, err := r.DB.Exec(
`UPDATE resources SET parent_id = $3, updated_at = NOW() `UPDATE resources SET parent_id = NULLIF($3, ''), updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`, WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL
resourceID, ownerID, parentID, AND ($3 = '' OR EXISTS (
SELECT 1 FROM resources
WHERE resource_id = $3 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL
))`,
resourceID, ownerID, parentResourceID,
) )
if err != nil && isUniqueViolation(err) { if err != nil && isUniqueViolation(err) {
return ErrNameConflict return ErrNameConflict
} }
if err != nil && isForeignKeyViolation(err) {
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
}
if err != nil { if err != nil {
return err return err
} }
@@ -386,7 +439,7 @@ func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) e
return nil return nil
} }
// UpdateName renames a resource. Absent source is a no-op. // UpdateName renames a resource. Absent / not owned → ErrNotFound.
func (r *Resources) UpdateName(ownerID, resourceID, name string) error { func (r *Resources) UpdateName(ownerID, resourceID, name string) error {
result, err := r.DB.Exec( result, err := r.DB.Exec(
`UPDATE resources SET name = $3, updated_at = NOW() `UPDATE resources SET name = $3, updated_at = NOW()
@@ -409,8 +462,18 @@ func (r *Resources) UpdateName(ownerID, resourceID, name string) error {
return nil return nil
} }
// UpdateNameOwned renames a resource OWNED by ownerID. Absent / not owned →
// ErrNotFound, sibling homonyme → ErrNameConflict. Variante scopée
// canonique (sémantique identique à UpdateName, nom aligné sur TouchOwned
// pour LOT 3).
func (r *Resources) UpdateNameOwned(ownerID, resourceID, name string) error {
return r.UpdateName(ownerID, resourceID, name)
}
// UpdateNameByID renames a resource without owner scoping — the caller // UpdateNameByID renames a resource without owner scoping — the caller
// (service) has already verified the user's effective access (editor+). // (service) has already verified the user's effective access (editor+).
// Conservée volontairement pour update_metadata : un editor non-owner peut
// renommer, UpdateNameOwned rejetterait à tort.
func (r *Resources) UpdateNameByID(resourceID, name string) error { func (r *Resources) UpdateNameByID(resourceID, name string) error {
result, err := r.DB.Exec( result, err := r.DB.Exec(
`UPDATE resources SET name = $2, updated_at = NOW() `UPDATE resources SET name = $2, updated_at = NOW()
@@ -433,6 +496,52 @@ func (r *Resources) UpdateNameByID(resourceID, name string) error {
return nil return nil
} }
// UpdatePhysical refreshes an existing file row's physical metadata
// (size_bytes / mime_type / extension) after a targeted re-upload — used so a
// resource created metadata-only (outbox create_resource) receives its bytes
// for server-side OCR. Absent / not owned → ErrNotFound. Never renames or moves.
func (r *Resources) UpdatePhysical(ownerID, resourceID string, size int64, mimeType, extension *string) error {
result, err := r.DB.Exec(
`UPDATE resources SET size_bytes = $3, mime_type = $4, extension = $5, updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND type = 'file' AND deleted_at IS NULL`,
resourceID, ownerID, size, mimeType, extension,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// UpdateOcrText writes the server-computed OCR extract onto the resource
// (owner-scoped, bumping updated_at so the change flows through the sync
// snapshot). The text is then readable by every device of the user AND by
// grantees via GET /files/:id/ocr (viewer+, cf. docs/api-v1.md §5).
func (r *Resources) UpdateOcrText(ownerID, resourceID, text string) error {
result, err := r.DB.Exec(
`UPDATE resources SET ocr_text = $3, updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND type = 'file' AND deleted_at IS NULL`,
resourceID, ownerID, text,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// SyncDelete soft-deletes a resource; absence is NOT an error (idempotent // SyncDelete soft-deletes a resource; absence is NOT an error (idempotent
// terminal state for the outbox). // terminal state for the outbox).
func (r *Resources) SyncDelete(ownerID, resourceID string) error { func (r *Resources) SyncDelete(ownerID, resourceID string) error {
@@ -457,8 +566,35 @@ func (r *Resources) ExistsOwner(ownerID, resourceID string) (bool, error) {
return err == nil, err return err == nil, err
} }
// TouchOwned bumps updated_at on a non-deleted resource OWNED by ownerID so
// that the grantee's delta snapshot picks it up after a share is created.
// Absent / not owned → ErrNotFound. C'est la variante scopée à utiliser
// (LOT 3 : migrer les appelants sync vers TouchOwned).
func (r *Resources) TouchOwned(ownerID, resourceID string) error {
result, err := r.DB.Exec(
`UPDATE resources SET updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
resourceID, ownerID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// TouchResource bumps updated_at on a non-deleted resource so that the // TouchResource bumps updated_at on a non-deleted resource so that the
// grantee's delta snapshot picks it up after a share is created. // grantee's delta snapshot picks it up after a share is created.
//
// Deprecated: non scopée (touche n'importe quel owner) — préférer TouchOwned.
// Plus aucun appelant sync (migrés vers TouchOwned) ; conservée pour
// compatibilité des appelants externes éventuels.
func (r *Resources) TouchResource(resourceID string) error { func (r *Resources) TouchResource(resourceID string) error {
_, err := r.DB.Exec( _, err := r.DB.Exec(
`UPDATE resources SET updated_at = NOW() WHERE resource_id = $1 AND deleted_at IS NULL`, `UPDATE resources SET updated_at = NOW() WHERE resource_id = $1 AND deleted_at IS NULL`,
+203 -2
View File
@@ -5,10 +5,10 @@ import (
"testing" "testing"
"time" "time"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
) )
const repositoryTestURL = "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_repository_test?sslmode=disable" const repositoryTestURL = "postgres://kazier:kazier@localhost:5432/kazier_repository_test?sslmode=disable"
func newTestResources(t *testing.T) *Resources { func newTestResources(t *testing.T) *Resources {
t.Helper() t.Helper()
@@ -232,3 +232,204 @@ func TestListOwnedDelta(t *testing.T) {
t.Errorf("delta attendu uniquement fresh.txt, got %+v", delta) t.Errorf("delta attendu uniquement fresh.txt, got %+v", delta)
} }
} }
func TestInsertParentCrossOwnerNotFound(t *testing.T) {
repo := newTestResources(t)
owner := NewID()
other := NewID()
mustInsertUser(t, repo, owner)
mustInsertUser(t, repo, other)
ownerFolder := NewID()
if err := repo.InsertFolder(owner, ownerFolder, "Docs", ""); err != nil {
t.Fatalf("insert folder: %v", err)
}
// Dossier d'un autre owner comme parent → NOT_FOUND (pas de fuite 500).
if err := repo.InsertFile(other, NewID(), "x.txt", ownerFolder, 1, nil, nil); !errors.Is(err, ErrNotFound) {
t.Errorf("parent autre owner : attendu ErrNotFound, got %v", err)
}
if err := repo.InsertFolder(other, NewID(), "Sub", ownerFolder); !errors.Is(err, ErrNotFound) {
t.Errorf("parent dossier autre owner : attendu ErrNotFound, got %v", err)
}
// Un fichier comme parent → NOT_FOUND (pas un folder).
fileID := NewID()
if err := repo.InsertFile(owner, fileID, "note.txt", "", 1, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
if err := repo.InsertFile(owner, NewID(), "y.txt", fileID, 1, nil, nil); !errors.Is(err, ErrNotFound) {
t.Errorf("parent fichier : attendu ErrNotFound, got %v", err)
}
}
func TestMoveResourceAtomic(t *testing.T) {
repo := newTestResources(t)
owner := NewID()
other := NewID()
mustInsertUser(t, repo, owner)
mustInsertUser(t, repo, other)
folderA := NewID()
folderB := NewID()
if err := repo.InsertFolder(owner, folderA, "A", ""); err != nil {
t.Fatalf("insert A: %v", err)
}
if err := repo.InsertFolder(owner, folderB, "B", ""); err != nil {
t.Fatalf("insert B: %v", err)
}
otherFolder := NewID()
if err := repo.InsertFolder(other, otherFolder, "Other", ""); err != nil {
t.Fatalf("insert other: %v", err)
}
fileID := NewID()
if err := repo.InsertFile(owner, fileID, "note.txt", folderA, 1, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
// Move OK vers dossier owned.
if err := repo.MoveResource(owner, fileID, folderB); err != nil {
t.Fatalf("move: %v", err)
}
got, err := repo.GetFile(owner, fileID)
if err != nil || got.FolderID != folderB {
t.Errorf("après move : folder=%q err=%v", got.FolderID, err)
}
// Cible d'un autre owner → NOT_FOUND, la source ne bouge pas.
if err := repo.MoveResource(owner, fileID, otherFolder); !errors.Is(err, ErrNotFound) {
t.Errorf("cible autre owner : attendu ErrNotFound, got %v", err)
}
got, _ = repo.GetFile(owner, fileID)
if got.FolderID != folderB {
t.Errorf("move refusé ne doit rien changer, folder=%q", got.FolderID)
}
// Cible inexistante → NOT_FOUND.
if err := repo.MoveResource(owner, fileID, NewID()); !errors.Is(err, ErrNotFound) {
t.Errorf("cible inconnue : attendu ErrNotFound, got %v", err)
}
// Source inconnue → NOT_FOUND.
if err := repo.MoveResource(owner, NewID(), folderB); !errors.Is(err, ErrNotFound) {
t.Errorf("source inconnue : attendu ErrNotFound, got %v", err)
}
// Retour à la racine.
if err := repo.MoveResource(owner, fileID, ""); err != nil {
t.Fatalf("move racine: %v", err)
}
got, _ = repo.GetFile(owner, fileID)
if got.FolderID != "" {
t.Errorf("racine attendue, folder=%q", got.FolderID)
}
}
func TestTouchOwnedAndUpdateNameOwned(t *testing.T) {
repo := newTestResources(t)
owner := NewID()
other := NewID()
mustInsertUser(t, repo, owner)
mustInsertUser(t, repo, other)
fileID := NewID()
if err := repo.InsertFile(owner, fileID, "note.txt", "", 1, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
before, err := repo.GetFile(owner, fileID)
if err != nil {
t.Fatalf("get: %v", err)
}
if err := repo.TouchOwned(owner, fileID); err != nil {
t.Fatalf("touch owned: %v", err)
}
after, err := repo.GetFile(owner, fileID)
if err != nil {
t.Fatalf("get après touch: %v", err)
}
if !after.UpdatedAt.After(before.UpdatedAt) && !after.UpdatedAt.Equal(before.UpdatedAt) {
t.Errorf("touch doit bumperc updated_at : %v → %v", before.UpdatedAt, after.UpdatedAt)
}
// Non-owned / inconnu → ErrNotFound.
if err := repo.TouchOwned(other, fileID); !errors.Is(err, ErrNotFound) {
t.Errorf("touch autre owner : attendu ErrNotFound, got %v", err)
}
if err := repo.TouchOwned(owner, NewID()); !errors.Is(err, ErrNotFound) {
t.Errorf("touch inconnu : attendu ErrNotFound, got %v", err)
}
if err := repo.UpdateNameOwned(owner, fileID, "renamed.txt"); err != nil {
t.Fatalf("rename owned: %v", err)
}
renamed, err := repo.GetFile(owner, fileID)
if err != nil || renamed.Name != "renamed.txt" {
t.Errorf("rename : %+v err=%v", renamed, err)
}
if err := repo.UpdateNameOwned(other, fileID, "volé.txt"); !errors.Is(err, ErrNotFound) {
t.Errorf("rename autre owner : attendu ErrNotFound, got %v", err)
}
if err := repo.UpdateNameOwned(owner, NewID(), "x.txt"); !errors.Is(err, ErrNotFound) {
t.Errorf("rename inconnu : attendu ErrNotFound, got %v", err)
}
// Anciennes variantes (deprecated, compat LOT 3) : toujours fonctionnelles.
if err := repo.TouchResource(fileID); err != nil {
t.Errorf("touch legacy: %v", err)
}
if err := repo.UpdateNameByID(fileID, "legacy.txt"); err != nil {
t.Errorf("rename legacy: %v", err)
}
}
func TestUpdateOcrTextAndReadBack(t *testing.T) {
repo := newTestResources(t)
owner := NewID()
other := NewID()
mustInsertUser(t, repo, owner)
mustInsertUser(t, repo, other)
fileID := NewID()
if err := repo.InsertFile(owner, fileID, "scan.png", "", 128, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
// Vide par défaut.
before := time.Now()
row, err := repo.GetFile(owner, fileID)
if err != nil {
t.Fatalf("get file: %v", err)
}
if row.OcrText != "" {
t.Errorf("ocr_text initial = %q, attendu vide", row.OcrText)
}
if err := repo.UpdateOcrText(owner, fileID, "extrait du scan"); err != nil {
t.Fatalf("update ocr_text: %v", err)
}
// L'exécution bump updated_at (→ delta outbox/snapshot).
time.Sleep(5 * time.Millisecond)
after, err := repo.GetFile(owner, fileID)
if err != nil {
t.Fatalf("get file après : %v", err)
}
if after.OcrText != "extrait du scan" {
t.Errorf("ocr_text = %q, attendu %q", after.OcrText, "extrait du scan")
}
if !after.UpdatedAt.After(before) {
t.Errorf("updated_at non bumpé: before=%v after=%v", before, after.UpdatedAt)
}
if after.UpdatedAt.Before(time.Now().Add(-time.Minute)) {
t.Errorf("updated_at incohérent: %v", after.UpdatedAt)
}
// Non-owner / ressource inconnue → ErrNotFound.
if err := repo.UpdateOcrText(other, fileID, "volé"); !errors.Is(err, ErrNotFound) {
t.Errorf("autre user : attendu ErrNotFound, got %v", err)
}
if err := repo.UpdateOcrText(owner, NewID(), "x"); !errors.Is(err, ErrNotFound) {
t.Errorf("inconnue : attendu ErrNotFound, got %v", err)
}
}
+74 -3
View File
@@ -327,17 +327,44 @@ func (s *Shares) ResourceExists(resourceID string) (bool, error) {
} }
// CreateLink stores a share link (token = id, client-generated 32-hex). // CreateLink stores a share link (token = id, client-generated 32-hex).
// Idempotent sur rejeu même (token) : ON CONFLICT DO NOTHING puis vérifie
// que le lien existant vise la même ressource ET le même owner (created_by) —
// sinon ErrNameConflict (réutilisation de token, cf. FEEDBACK #3). Un lien
// révoqué identique reste révoqué (pas de résurrection par rejeu : revoke gagne).
func (s *Shares) CreateLink(token, resourceID, access string, expiresAt *time.Time, createdBy string) error { func (s *Shares) CreateLink(token, resourceID, access string, expiresAt *time.Time, createdBy string) error {
var expires any var expires any
if expiresAt != nil { if expiresAt != nil {
expires = *expiresAt expires = *expiresAt
} }
_, err := s.DB.Exec( res, err := s.DB.Exec(
`INSERT INTO share_links (id, resource_id, access, created_by, expires_at) `INSERT INTO share_links (id, resource_id, access, created_by, expires_at)
VALUES ($1, $2, $3, $4, $5)`, VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (id) DO NOTHING`,
token, resourceID, access, createdBy, expires, token, resourceID, access, createdBy, expires,
) )
return err if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 1 {
return nil
}
// Conflit : le token existe déjà — idempotent si même (ressource, owner),
// sinon conflit (le token est une clé d'idempotence client).
var existing struct {
resourceID string
createdBy string
}
if err := s.DB.QueryRow(`SELECT resource_id, created_by FROM share_links WHERE id = $1`, token).Scan(&existing.resourceID, &existing.createdBy); err != nil {
return err
}
if existing.resourceID != resourceID || existing.createdBy != createdBy {
return ErrNameConflict
}
return nil
} }
// RevokeLink soft-revokes a link by token. Returns ErrNotFound if the link // RevokeLink soft-revokes a link by token. Returns ErrNotFound if the link
@@ -428,5 +455,49 @@ func (s *Shares) ListActiveLinksForResource(resourceID string) ([]LinkInfo, erro
return links, rows.Err() return links, rows.Err()
} }
// ShareGrant is one active user-to-user grant on a resource (owner view).
type ShareGrant struct {
GranteeUserID string
Username string
Access string
Inherit bool
ExpiresAt *time.Time
UpdatedAt time.Time
}
// ListActiveForResource returns the active (non-revoked) grants on a resource,
// oldest first. Expired grants are included (the owner sees what will lapse);
// the caller filters display. Empty (not error) when nothing is shared.
func (s *Shares) ListActiveForResource(resourceID string) ([]ShareGrant, error) {
rows, err := s.DB.Query(
`SELECT s.grantee_user_id, COALESCE(u.username, s.grantee_user_id),
s.access, s.inherit, s.expires_at, s.updated_at
FROM shares s
LEFT JOIN users u ON u.id = s.grantee_user_id AND u.deleted_at IS NULL
WHERE s.resource_id = $1 AND s.revoked_at IS NULL
ORDER BY s.created_at ASC`,
resourceID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var grants []ShareGrant
for rows.Next() {
var (
g ShareGrant
expiresAt sql.NullTime
)
if err := rows.Scan(&g.GranteeUserID, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil {
return nil, err
}
if expiresAt.Valid {
g.ExpiresAt = &expiresAt.Time
}
grants = append(grants, g)
}
return grants, rows.Err()
}
// Errors specific to shares. // Errors specific to shares.
var ErrGranteeNotFound = errors.New("grantee user not found") var ErrGranteeNotFound = errors.New("grantee user not found")
+42 -15
View File
@@ -20,11 +20,12 @@ type Users struct {
DB *sql.DB DB *sql.DB
} }
// Count retourne le nombre d'utilisateurs (y compris supprimés) — sert au // Count retourne le nombre d'utilisateurs ACTIFS (deleted_at IS NULL) — sert
// bootstrap admin au démarrage. // au bootstrap admin au démarrage. Une base dont tous les comptes sont
// soft-deleted est vue comme vide : EnsureAdmin recréera un admin (#9+A10).
func (u *Users) Count() (int, error) { func (u *Users) Count() (int, error) {
var n int var n int
err := u.DB.QueryRow(`SELECT COUNT(*) FROM users`).Scan(&n) err := u.DB.QueryRow(`SELECT COUNT(*) FROM users WHERE deleted_at IS NULL`).Scan(&n)
return n, err return n, err
} }
@@ -67,8 +68,11 @@ func (u *Users) ResolveExact(normalized string) (*UserRow, error) {
// Create insère un compte avec un id 32-hex généré. Retourne l'id. // Create insère un compte avec un id 32-hex généré. Retourne l'id.
func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmin bool) (string, error) { func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmin bool) (string, error) {
id := NewID() id, err := NewIDErr()
_, err := u.DB.Exec( if err != nil {
return "", err
}
_, err = u.DB.Exec(
`INSERT INTO users (id, username, username_normalized, password_hash, is_admin, created_at) `INSERT INTO users (id, username, username_normalized, password_hash, is_admin, created_at)
VALUES ($1, $2, $3, $4, $5, NOW())`, VALUES ($1, $2, $3, $4, $5, NOW())`,
id, username, usernameNormalized, passwordHash, isAdmin, id, username, usernameNormalized, passwordHash, isAdmin,
@@ -82,24 +86,47 @@ func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmi
return id, nil return id, nil
} }
// UpdatePassword remplace le hash du compte. Les tokens déjà émis restent // UpdatePassword remplace le hash du compte actif. Compte absent ou
// valides 7 jours : limite assumée V1 (pas de liste de révocation). // soft-deleted → ErrNotFound. Les tokens déjà émis restent valides 7 jours :
// limite assumée V1 (pas de liste de révocation).
func (u *Users) UpdatePassword(id, newHash string) error { func (u *Users) UpdatePassword(id, newHash string) error {
_, err := u.DB.Exec( result, err := u.DB.Exec(
`UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1`, `UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
id, newHash, id, newHash,
) )
return err if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
} }
// MarkDeleted soft-delete un compte : les tokens issus sont rejetés par le // MarkDeleted soft-delete un compte actif : les tokens issus sont rejetés par
// middleware (GetByID filtre deleted_at). // le middleware (GetByID filtre deleted_at). Compte absent ou déjà supprimé →
// ErrNotFound (pas d'idempotence silencieuse : le second delete signale que
// la cible n'est plus active).
func (u *Users) MarkDeleted(id string) error { func (u *Users) MarkDeleted(id string) error {
_, err := u.DB.Exec( result, err := u.DB.Exec(
`UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1`, `UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
id, id,
) )
return err if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
} }
func scanUser(scan func(...any) error) (*UserRow, error) { func scanUser(scan func(...any) error) (*UserRow, error) {
+23 -3
View File
@@ -4,7 +4,7 @@ import (
"errors" "errors"
"testing" "testing"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
) )
func newTestUsers(t *testing.T) *Users { func newTestUsers(t *testing.T) *Users {
@@ -64,6 +64,11 @@ func TestUsersUpdatePassword(t *testing.T) {
if err != nil || row.PasswordHash != "hash-2" { if err != nil || row.PasswordHash != "hash-2" {
t.Errorf("hash après update = %q (err=%v)", row.PasswordHash, err) t.Errorf("hash après update = %q (err=%v)", row.PasswordHash, err)
} }
// Compte inconnu → ErrNotFound (#9+A10).
if err := u.UpdatePassword(NewID(), "hash-x"); !errors.Is(err, ErrNotFound) {
t.Errorf("update password inconnu : attendu ErrNotFound, got %v", err)
}
} }
func TestUsersMarkDeletedHidesAccount(t *testing.T) { func TestUsersMarkDeletedHidesAccount(t *testing.T) {
@@ -82,7 +87,22 @@ func TestUsersMarkDeletedHidesAccount(t *testing.T) {
if _, err := u.GetByUsernameNormalized("carol"); !errors.Is(err, ErrNotFound) { if _, err := u.GetByUsernameNormalized("carol"); !errors.Is(err, ErrNotFound) {
t.Errorf("get par username après suppression : attendu ErrNotFound, got %v", err) t.Errorf("get par username après suppression : attendu ErrNotFound, got %v", err)
} }
if n, _ := u.Count(); n != 1 { // Count ne compte que les ACTIFS : carol soft-deleted → 0 (#9+A10). Une
t.Errorf("count doit compter aussi les supprimés (bootstrap), got %d", n) // base 100% soft-deleted est vue comme vide par le bootstrap.
if n, _ := u.Count(); n != 0 {
t.Errorf("count doit exclure les supprimés, got %d", n)
}
// UpdatePassword sur compte supprimé → ErrNotFound.
if err := u.UpdatePassword(id, "hash-2"); !errors.Is(err, ErrNotFound) {
t.Errorf("update password après suppression : attendu ErrNotFound, got %v", err)
}
// Second MarkDeleted → ErrNotFound (plus de cible active).
if err := u.MarkDeleted(id); !errors.Is(err, ErrNotFound) {
t.Errorf("second mark deleted : attendu ErrNotFound, got %v", err)
}
// MarkDeleted sur inconnu → ErrNotFound.
if err := u.MarkDeleted(NewID()); !errors.Is(err, ErrNotFound) {
t.Errorf("mark deleted inconnu : attendu ErrNotFound, got %v", err)
} }
} }
+5 -3
View File
@@ -5,8 +5,8 @@ import (
"fmt" "fmt"
"strings" "strings"
"github.com/vaultdrop/backend/pkg/passwd" "github.com/kazier/backend/pkg/passwd"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
// ErrAdminRequired : base vide et identifiants admin absents → le serveur // ErrAdminRequired : base vide et identifiants admin absents → le serveur
@@ -21,7 +21,9 @@ func NormalizeUsername(username string) string {
} }
// EnsureAdmin crée le compte admin au premier démarrage si la table users est // EnsureAdmin crée le compte admin au premier démarrage si la table users est
// vide. Idempotent : l'env n'écrase jamais un compte existant. // vide. Idempotent : l'env n'écrase jamais un compte existant. Seuls les
// comptes ACTIFS comptent (Users.Count filtre deleted_at, #9+A10) : une base
// 100% soft-deleted est vue comme vide et reçoit un nouvel admin.
func EnsureAdmin(repo *repository.Repository, username, password string) error { func EnsureAdmin(repo *repository.Repository, username, password string) error {
count, err := repo.Users.Count() count, err := repo.Users.Count()
if err != nil { if err != nil {
+28 -2
View File
@@ -4,8 +4,8 @@ import (
"errors" "errors"
"testing" "testing"
"github.com/vaultdrop/backend/pkg/passwd" "github.com/kazier/backend/pkg/passwd"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
func TestEnsureAdminCreatesFirstAdmin(t *testing.T) { func TestEnsureAdminCreatesFirstAdmin(t *testing.T) {
@@ -60,6 +60,32 @@ func TestEnsureAdminRefusesOnEmptyDBWithoutEnv(t *testing.T) {
} }
} }
func TestEnsureAdminRecreatesWhenAllSoftDeleted(t *testing.T) {
s := newServiceStore(t)
repo := s.Repository
// Un seul compte, soft-deleted : Count (actifs seuls, #9+A10) voit une
// base vide → EnsureAdmin recrée un admin au lieu de refuser.
id, err := repo.Users.Create("alice", "alice", "existing-hash", false)
if err != nil {
t.Fatalf("seed user: %v", err)
}
if err := repo.Users.MarkDeleted(id); err != nil {
t.Fatalf("mark deleted: %v", err)
}
if err := EnsureAdmin(repo, "admin", "admin-secret-123"); err != nil {
t.Fatalf("EnsureAdmin sur base 100%% soft-deleted : %v", err)
}
admin, err := repo.Users.GetByUsernameNormalized("admin")
if err != nil {
t.Fatalf("admin recréé introuvable: %v", err)
}
if !admin.IsAdmin {
t.Error("le compte recréé doit être admin")
}
}
func TestEnsureAdminNeverOverwritesExistingAccounts(t *testing.T) { func TestEnsureAdminNeverOverwritesExistingAccounts(t *testing.T) {
s := newServiceStore(t) s := newServiceStore(t)
repo := s.Repository repo := s.Repository
-14
View File
@@ -1,14 +0,0 @@
package service
import "github.com/vaultdrop/backend/models"
func (s *Services) CreateFolder(folderName string, destination *models.Document) (error, *models.Document) {
err, directory := models.NewDocument(folderName, models.DIRECTORY, 1)
if err != nil {
return err, nil
}
return nil, directory
}
-33
View File
@@ -1,33 +0,0 @@
package service
import (
"fmt"
"github.com/vaultdrop/backend/models"
)
func (s *Services) MoveDocumentIntoDocument(from *models.Document, to *models.Document) error {
if from.UUID == nil {
return fmt.Errorf(models.ERROR_DOCUMENT_NOT_PERCISTED)
}
if to.Type != models.DIRECTORY {
return fmt.Errorf("The destination document must be a directory")
}
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, from); canEdit == false {
return fmt.Errorf("You can not edit this folder")
}
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, to); canEdit == false {
return fmt.Errorf("You can not edit this folder")
}
// Check if document exist and move the document into document if is directory
fmt.Println("To implement move to ", to.UUID)
return nil
}
-52
View File
@@ -1,52 +0,0 @@
package service
import (
"testing"
"github.com/vaultdrop/backend/models"
)
func TestMoveDocument(t *testing.T) {
err, userAntoine := models.NewUser("antoine")
if err != nil {
t.Errorf(`Error creating antoine user %v`, err)
}
fakeUUID := "dsqdsq"
err, document := models.NewDocument("test.pdf", models.FILE, 1)
document.UUID = &fakeUUID
err, folder := models.NewDocument("orga", models.DIRECTORY, 1)
folder.UUID = &fakeUUID
service := New(userAntoine)
err = service.MoveDocumentIntoDocument(document, folder)
if err != nil {
t.Error(err)
}
}
func TestMoveDocumentToAFile(t *testing.T) {
err, userAntoine := models.NewUser("antoine")
if err != nil {
t.Errorf(`Error creating antoine user %v`, err)
}
err, document := models.NewDocument("test.pdf", models.FILE, 1)
err, notAFolder := models.NewDocument("orga", models.FILE, 1)
service := New(userAntoine)
err = service.MoveDocumentIntoDocument(document, notAFolder)
if err == nil {
t.Error(err)
}
}
+153 -19
View File
@@ -2,11 +2,26 @@ package service
import ( import (
"context" "context"
"errors"
"fmt"
"log"
"os"
"path/filepath" "path/filepath"
"regexp"
"strings" "strings"
"sync"
"time"
"github.com/vaultdrop/backend/ocr" "github.com/kazier/backend/ocr"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
)
const (
// StaleClaimTimeout : un job `processing` plus vieux que ça est ré-enfilé
// au boot (worker mort / process redémarré).
StaleClaimTimeout = 15 * time.Minute
// QueuePollInterval : cadence de scrutation quand la file est vide.
QueuePollInterval = time.Second
) )
// OcrJobDTO serializes exactly as mobile/api/types.ts OcrJob. // OcrJobDTO serializes exactly as mobile/api/types.ts OcrJob.
@@ -17,22 +32,46 @@ type OcrJobDTO struct {
Error string `json:"error,omitempty"` Error string `json:"error,omitempty"`
} }
// Ocr queues OCR jobs and processes them asynchronously (V1 : goroutine par // Ocr queues OCR jobs in `ocr_jobs` (status `queued`) and processes them
// job ; le client poll GET /ocr/jobs/:id toutes les 3s). // asynchronously through a bounded worker ([Run]) — Tesseract ne tourne jamais
// dans un request handler. Le client poll GET /ocr/jobs/:id toutes les 3s.
type Ocr struct { type Ocr struct {
Repository *repository.Repository Repository *repository.Repository
UploadDir string UploadDir string
Lang string Lang string
Engine ocr.Engine Engine ocr.Engine
StaleAfter time.Duration
} }
func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr { func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr {
return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: lang, Engine: engine} return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: normalizeOcrLang(lang), Engine: engine, StaleAfter: StaleClaimTimeout}
} }
// Create valide la ressource (ownership par user), met le job en file et var (
// lance le traitement. Le job reste scopé par device (le service génère les // ocrLangPattern : whitelist OCR_LANG (A12) — lettres Tesseract + `+`
// jobs du device courant ; l'outbox OCR n'est pas synchronisée entre devices). // uniquement (ex. `fra`, `eng`, `fra+eng`). Tout le reste (espaces,
// `;`, `-`, options `--...`) est une tentative d'injection `-l`.
ocrLangPattern = regexp.MustCompile(`^[a-z+]{2,20}$`)
// hexIDPattern : identifiants 32-hex (anti `..` dans physicalPath).
hexIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
)
// DefaultOcrLang est la langue Tesseract de repli (OCR_LANG, défaut fra+eng).
const DefaultOcrLang = "fra+eng"
// normalizeOcrLang applique la whitelist OCR_LANG : valeur invalide → repli
// sur le défaut avec log (jamais d'injection vers `tesseract -l`).
func normalizeOcrLang(lang string) string {
if ocrLangPattern.MatchString(lang) {
return lang
}
log.Printf("ocr: OCR_LANG %q invalide (whitelist ^[a-z+]{2,20}$), repli sur %q", lang, DefaultOcrLang)
return DefaultOcrLang
}
// Create valide la ressource (ownership par user) et l'enfile uniquement
// (status `queued`) — le traitement est délégué au worker [Run] pour ne pas
// stresser le serveur. Le job reste scopé par device.
func (o *Ocr) Create(userID, deviceID, fileID string) (OcrJobDTO, error) { func (o *Ocr) Create(userID, deviceID, fileID string) (OcrJobDTO, error) {
if _, err := o.Repository.Resources.GetFile(userID, fileID); err != nil { if _, err := o.Repository.Resources.GetFile(userID, fileID); err != nil {
return OcrJobDTO{}, err return OcrJobDTO{}, err
@@ -41,7 +80,6 @@ func (o *Ocr) Create(userID, deviceID, fileID string) (OcrJobDTO, error) {
if err := o.Repository.OcrJobs.Create(jobID, deviceID, fileID); err != nil { if err := o.Repository.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
return OcrJobDTO{}, err return OcrJobDTO{}, err
} }
go o.process(userID, deviceID, jobID, fileID)
return OcrJobDTO{ID: jobID, Status: "queued"}, nil return OcrJobDTO{ID: jobID, Status: "queued"}, nil
} }
@@ -53,35 +91,131 @@ func (o *Ocr) Get(deviceID, jobID string) (OcrJobDTO, error) {
return toOcrJobDTO(row), nil return toOcrJobDTO(row), nil
} }
func (o *Ocr) process(userID, deviceID, jobID, fileID string) { // Run fait tourner le worker OCR : au démarrage il requeue les jobs laissés
ctx := context.Background() // en `processing` (crash), puis `workers` boucles consomment la file FIFO via
if err := o.Repository.OcrJobs.TouchProcessing(deviceID, jobID); err != nil { // ClaimNext (atomique, `FOR UPDATE SKIP LOCKED`). `workers` borne la
// concurrence Tesseract. Retourne quand ctx est annulé.
func (o *Ocr) Run(ctx context.Context, workers int) {
if workers < 1 {
workers = 1
}
if _, err := o.Repository.OcrJobs.ResetStaleProcessing(o.StaleAfter); err != nil {
log.Printf("ocr: requeue jobs stale: %v", err)
}
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
o.workerLoop(ctx)
}()
}
wg.Wait()
}
// workerLoop consomme la file : un job `queued` → processing → done/failed.
// File vide → scrutation à QueuePollInterval jusqu'à annulation du ctx.
func (o *Ocr) workerLoop(ctx context.Context) {
for {
row, err := o.Repository.OcrJobs.ClaimNext()
if err != nil {
if !errors.Is(err, repository.ErrNoQueuedJobs) {
log.Printf("ocr: claim: %v", err)
}
select {
case <-ctx.Done():
return
case <-time.After(QueuePollInterval):
}
continue
}
o.process(ctx, row)
}
}
// process exécute l'extraction pour un job déjà réclamé (`processing`).
// Ordre A13 : l'écriture `UpdateOcrText` est vérifiée AVANT le `Complete` —
// hôte supprimé entre-temps (0 ligne, ErrNotFound) → le job `Fail` au lieu
// de rester `done` avec un texte fantôme. Les erreurs `Fail`/`Complete`
// (conflit d'état : job requeue et repris par un autre worker) sont loggées,
// jamais silencieuses.
func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
fail := func(message string) {
if err := o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, message); err != nil {
log.Printf("ocr: fail job %s: %v", row.ID, err)
}
}
complete := func(text string) {
if err := o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text); err != nil {
log.Printf("ocr: complete job %s: %v", row.ID, err)
}
}
userID, err := o.Repository.Resources.GetResourceOwner(row.FileID)
if err != nil {
fail("file not readable")
return return
} }
path, err := o.physicalPath(userID, fileID) path, err := o.physicalPath(userID, row.FileID)
if err != nil { if err != nil {
_ = o.Repository.OcrJobs.Fail(deviceID, jobID, "file not readable") fail("file not readable")
return return
} }
text, err := o.Engine.ExtractText(ctx, path, o.Lang) text, err := o.Engine.ExtractText(ctx, path, o.Lang)
if err != nil { if err != nil {
_ = o.Repository.OcrJobs.Fail(deviceID, jobID, err.Error()) fail(err.Error())
return return
} }
_ = o.Repository.OcrJobs.Complete(deviceID, jobID, text) // Le texte atterrit sur la ressource (updated_at bumpé) : consultable par
// tous les devices du user et les grantees via GET /files/:id/ocr.
if trimmed := strings.TrimSpace(text); trimmed != "" {
if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil {
if errors.Is(err, repository.ErrNotFound) {
fail("file not readable")
} else {
fail(err.Error())
}
return
}
}
complete(text)
} }
// physicalPath résout UPLOAD_DIR/<user_id>/<resource_id>.<ext> — l'ext est // physicalPath résout UPLOAD_DIR/<user_id>/<resource_id>.<ext> — l'ext est
// choisi à l'upload, le fichier réel est retrouvé par préfixe. // choisi à l'upload, le fichier réel est retrouvé par préfixe. Durci (A12) :
// identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier
// (ni dossier, ni symlink brut), `EvalSymlinks` contenu dans UPLOAD_DIR
// (anti évasion par lien symbolique). Candidat rejeté → candidat suivant ;
// aucun candidat → ErrNotFound.
func (o *Ocr) physicalPath(userID, fileID string) (string, error) { func (o *Ocr) physicalPath(userID, fileID string) (string, error) {
if !hexIDPattern.MatchString(userID) || !hexIDPattern.MatchString(fileID) {
return "", fmt.Errorf("physicalPath: identifiant non 32-hex")
}
base, err := filepath.EvalSymlinks(o.UploadDir)
if err != nil {
return "", fmt.Errorf("physicalPath: upload dir illisible: %w", err)
}
matches, err := filepath.Glob(filepath.Join(o.UploadDir, userID, fileID+".*")) matches, err := filepath.Glob(filepath.Join(o.UploadDir, userID, fileID+".*"))
if err != nil { if err != nil {
return "", err return "", err
} }
for _, m := range matches { for _, m := range matches {
if strings.HasPrefix(filepath.Base(m), fileID+".") { if !strings.HasPrefix(filepath.Base(m), fileID+".") {
return m, nil continue
} }
fi, err := os.Lstat(m)
if err != nil || !fi.Mode().IsRegular() {
continue
}
resolved, err := filepath.EvalSymlinks(m)
if err != nil {
continue
}
rel, err := filepath.Rel(base, resolved)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
return resolved, nil
} }
return "", repository.ErrNotFound return "", repository.ErrNotFound
} }
+132 -4
View File
@@ -9,8 +9,8 @@ import (
"testing" "testing"
"time" "time"
"github.com/vaultdrop/backend/ocr" "github.com/kazier/backend/ocr"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
// stubEngine again (package service) — même contrat que handlers/ocr_test. // stubEngine again (package service) — même contrat que handlers/ocr_test.
@@ -26,13 +26,18 @@ func (s stubEngine) ExtractText(_ context.Context, _ string, _ string) (string,
return s.text, nil return s.text, nil
} }
// newTestOcr builds an Ocr over a fresh DB and returns it with the ids. // newTestOcr builds an Ocr over a fresh DB, starts the bounded worker (1
// worker) and returns it with the ids.
func newTestOcr(t *testing.T, uploadDir string, engine ocr.Engine) (*Ocr, string, string, string) { func newTestOcr(t *testing.T, uploadDir string, engine ocr.Engine) (*Ocr, string, string, string) {
t.Helper() t.Helper()
s := newServiceStore(t) s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "ocr-failed") userID := mustCreateUser(t, s.Repository, "ocr-failed")
deviceID := mustRegisterDevice(t, s.Repository, repository.NewID()) deviceID := mustRegisterDevice(t, s.Repository, repository.NewID())
return NewOcr(s.Repository, uploadDir, "fra+eng", engine), userID, deviceID, uploadDir o := NewOcr(s.Repository, uploadDir, "fra+eng", engine)
ctx, cancel := context.WithCancel(context.Background())
go o.Run(ctx, 1)
t.Cleanup(cancel)
return o, userID, deviceID, uploadDir
} }
// waitTillTerminal poll jusqu'à un statut terminal (done/failed). // waitTillTerminal poll jusqu'à un statut terminal (done/failed).
@@ -89,6 +94,76 @@ func TestOcrPhysicalPath(t *testing.T) {
} }
} }
func TestOcrPhysicalPathRejectsNonHexIDs(t *testing.T) {
o := NewOcr(nil, t.TempDir(), "fra+eng", nil)
for _, tc := range [][2]string{
{"../evil", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"},
{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "../../etc/passwd.png"},
{"", ""},
} {
if _, err := o.physicalPath(tc[0], tc[1]); err == nil {
t.Errorf("ids %q/%q : attendu rejet non 32-hex", tc[0], tc[1])
}
}
}
func TestOcrPhysicalPathRejectsSymlinkEscape(t *testing.T) {
uploadDir := t.TempDir()
userID := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
fileID := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
outside := t.TempDir()
secret := filepath.Join(outside, "secret.png")
if err := os.WriteFile(secret, []byte("secret"), 0o644); err != nil {
t.Fatalf("write secret: %v", err)
}
userDir := filepath.Join(uploadDir, userID)
if err := os.MkdirAll(userDir, 0o755); err != nil {
t.Fatalf("mkdir: %v", err)
}
// Lien symbolique <fileID>.png → hors UPLOAD_DIR : doit être ignoré.
if err := os.Symlink(secret, filepath.Join(userDir, fileID+".png")); err != nil {
t.Fatalf("symlink: %v", err)
}
o := NewOcr(nil, uploadDir, "fra+eng", nil)
if _, err := o.physicalPath(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Errorf("symlink hors UPLOAD_DIR : attendu ErrNotFound, got %v", err)
}
}
func TestOcrPhysicalPathRejectsDirectory(t *testing.T) {
uploadDir := t.TempDir()
userID := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
fileID := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
userDir := filepath.Join(uploadDir, userID)
if err := os.MkdirAll(filepath.Join(userDir, fileID+".png"), 0o755); err != nil {
t.Fatalf("mkdir: %v", err)
}
o := NewOcr(nil, uploadDir, "fra+eng", nil)
if _, err := o.physicalPath(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Errorf("dossier à la place du fichier : attendu ErrNotFound, got %v", err)
}
}
func TestNormalizeOcrLang(t *testing.T) {
for _, lang := range []string{"fra", "eng", "fra+eng"} {
if got := normalizeOcrLang(lang); got != lang {
t.Errorf("langue %q : attendue conservée, got %q", lang, got)
}
}
for _, lang := range []string{"", "e", "fra;id", "fra eng", "FRA", "--psm 6 fra"} {
if got := normalizeOcrLang(lang); got != DefaultOcrLang {
t.Errorf("langue %q : attendu repli %q, got %q", lang, DefaultOcrLang, got)
}
}
o := NewOcr(nil, t.TempDir(), "fra;evil", nil)
if o.Lang != DefaultOcrLang {
t.Errorf("NewOcr langue hostile : attendu %q, got %q", DefaultOcrLang, o.Lang)
}
}
func TestOcrJobFailsWhenPhysicalFileMissing(t *testing.T) { func TestOcrJobFailsWhenPhysicalFileMissing(t *testing.T) {
o, userID, deviceID, _ := newTestOcr(t, t.TempDir(), stubEngine{text: "x"}) o, userID, deviceID, _ := newTestOcr(t, t.TempDir(), stubEngine{text: "x"})
@@ -105,6 +180,59 @@ func TestOcrJobFailsWhenPhysicalFileMissing(t *testing.T) {
} }
} }
func TestOcrJobPersistsTextOnResourceAndGrantsRead(t *testing.T) {
uploadDir := t.TempDir()
o, ownerID, deviceID, _ := newTestOcr(t, uploadDir, stubEngine{text: " extrait du scan "})
granteeID := mustCreateUser(t, o.Repository, "ocr-grantee")
outsiderID := mustCreateUser(t, o.Repository, "ocr-outsider")
mustRegisterDevice(t, o.Repository, shareTestDeviceID)
fileID := repository.NewID()
insertOcrFile(t, o, ownerID, fileID)
if err := os.MkdirAll(filepath.Join(uploadDir, ownerID), 0o755); err != nil {
t.Fatalf("mkdir: %v", err)
}
if err := os.WriteFile(filepath.Join(uploadDir, ownerID, fileID+".png"), []byte("img"), 0o644); err != nil {
t.Fatalf("write: %v", err)
}
job, err := o.Create(ownerID, deviceID, fileID)
if err != nil {
t.Fatalf("create: %v", err)
}
row := waitTillTerminal(t, o, deviceID, job.ID)
if row.Status != "done" {
t.Fatalf("job %s: attendu done", row.Status)
}
// Le texte (trimé) a atterri sur la ressource, lisible par l'owner.
s := NewResources(o.Repository, uploadDir, 100)
owned, err := s.GetFileOcr(ownerID, fileID)
if err != nil {
t.Fatalf("get ocr owner: %v", err)
}
if owned.Text != "extrait du scan" {
t.Errorf("ocr_text = %q, attendu %q", owned.Text, "extrait du scan")
}
// ... et par un grantee viewer+ (docs §5 : partage rend le texte lisible).
if err := o.Repository.Shares.Upsert(fileID, granteeID, "viewer", false, nil, ownerID); err != nil {
t.Fatalf("share: %v", err)
}
shared, err := s.GetFileOcr(granteeID, fileID)
if err != nil {
t.Fatalf("get ocr grantee: %v", err)
}
if shared.Text != "extrait du scan" {
t.Errorf("ocr_text grantee = %q, attendu %q", shared.Text, "extrait du scan")
}
// Un tiers n'y a pas accès.
if _, err := s.GetFileOcr(outsiderID, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Errorf("tiers : attendu ErrNotFound, got %v", err)
}
}
func TestOcrJobFailsOnEngineError(t *testing.T) { func TestOcrJobFailsOnEngineError(t *testing.T) {
uploadDir := t.TempDir() uploadDir := t.TempDir()
o, userID, deviceID, _ := newTestOcr(t, uploadDir, stubEngine{err: errors.New("tesseract boom")}) o, userID, deviceID, _ := newTestOcr(t, uploadDir, stubEngine{err: errors.New("tesseract boom")})
+293 -26
View File
@@ -4,17 +4,23 @@ import (
"errors" "errors"
"fmt" "fmt"
"io" "io"
"log"
"mime/multipart" "mime/multipart"
"os" "os"
"path/filepath" "path/filepath"
"regexp"
"strings" "strings"
"time" "time"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
// FileTooLargeError signals an upload above MaxFileSize. // ErrFileTooLarge signals an upload above MaxFileSize.
var FileTooLargeError = errors.New("file too large") var ErrFileTooLarge = errors.New("file too large")
// ErrInvalidUpload signals a rejected upload (display name or path component).
// Handlers map it to 400 INVALID_REQUEST (never 500).
var ErrInvalidUpload = errors.New("invalid upload name")
// FileDTO serializes exactly as mobile/api/types.ts FileDto. // FileDTO serializes exactly as mobile/api/types.ts FileDto.
type FileDTO struct { type FileDTO struct {
@@ -53,6 +59,66 @@ func NewResources(repo *repository.Repository, uploadDir string, maxFileSize int
} }
} }
var (
extensionPattern = regexp.MustCompile(`^[a-z0-9]{1,10}$`)
idPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
)
// allowedMimeTypes whitelists client-declared Content-Types (parameters
// stripped, lowercased) ; anything absent falls back to
// application/octet-stream (cf. FEEDBACK A16).
var allowedMimeTypes = map[string]struct{}{
"application/octet-stream": {},
"application/pdf": {},
"application/json": {},
"application/zip": {},
"text/plain": {},
"text/csv": {},
"text/markdown": {},
"image/png": {},
"image/jpeg": {},
"image/gif": {},
"image/webp": {},
"audio/mpeg": {},
"video/mp4": {},
}
// sanitizeExtension normalise l'extension issue du filename client (cf.
// FEEDBACK #5) : lowercase, [a-z0-9]{1,10}, sinon "" (pas de suffixe).
func sanitizeExtension(filename string) string {
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
if !extensionPattern.MatchString(ext) {
return ""
}
return ext
}
// sanitizeFileName nettoie le nom stocké (cf. FEEDBACK A16) : TrimSpace,
// cap 255, rejet vide / slash / backslash / retour ligne. Le nom n'est
// qu'une métadonnée (jamais un composant de chemin), mais on le verrouille
// quand même pour casser toute confusion downstream.
func sanitizeFileName(name string) (string, error) {
n := strings.TrimSpace(name)
if n == "" || len(n) > 255 || strings.ContainsAny(n, "/\\\x00\n\r") {
return "", ErrInvalidUpload
}
return n, nil
}
func sanitizeMimeType(mime string) string {
m := strings.ToLower(strings.TrimSpace(mime))
if i := strings.IndexByte(m, ';'); i >= 0 {
m = strings.TrimSpace(m[:i])
}
if m == "" || len(m) > 128 {
return "application/octet-stream"
}
if _, ok := allowedMimeTypes[m]; !ok {
return "application/octet-stream"
}
return m
}
func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) { func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) {
rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order) rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order)
if err != nil { if err != nil {
@@ -73,6 +139,86 @@ func (s *Resources) GetFile(ownerID, id string) (FileDTO, error) {
return toFileDTO(row), nil return toFileDTO(row), nil
} }
// FileOcrDTO is the payload of GET /files/:id/ocr: the server-computed OCR
// extract of the resource, readable by its owner and by grantees (viewer+).
type FileOcrDTO struct {
Text string `json:"text"`
UpdatedAt string `json:"updatedAt,omitempty"`
}
// ContentInfo describes the physical bytes of a file the user can see
// (viewer+, own or shared) for GET /files/:id/content (streaming lecture,
// jamais persisté côté client en V1 streaming).
type ContentInfo struct {
Path string
Name string
MimeType string
Size int64
}
// OpenContent resolves the physical file of a visible resource. Auth is
// viewer+ (GetFileVisible, own or shared) ; the bytes live under the OWNER
// dir (UPLOAD_DIR/<owner_id>/<resource_id>.<ext>), never under the requester.
// No physical file (metadata-only outbox resource, never uploaded) →
// repository.ErrNotFound (handler maps to 404 NOT_FOUND, same as invisible).
func (s *Resources) OpenContent(userID, resourceID string) (ContentInfo, error) {
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return ContentInfo{}, err
}
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return ContentInfo{}, err
}
if !idPattern.MatchString(ownerID) || !idPattern.MatchString(resourceID) {
return ContentInfo{}, repository.ErrNotFound
}
base, err := filepath.EvalSymlinks(s.UploadDir)
if err != nil {
return ContentInfo{}, repository.ErrNotFound
}
matches, err := filepath.Glob(filepath.Join(s.UploadDir, ownerID, resourceID+".*"))
if err != nil {
return ContentInfo{}, repository.ErrNotFound
}
for _, m := range matches {
if !strings.HasPrefix(filepath.Base(m), resourceID+".") {
continue
}
fi, err := os.Lstat(m)
if err != nil || !fi.Mode().IsRegular() {
continue
}
resolved, err := filepath.EvalSymlinks(m)
if err != nil {
continue
}
rel, err := filepath.Rel(base, resolved)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
mime := row.MimeType
if mime == "" {
mime = "application/octet-stream"
}
return ContentInfo{Path: resolved, Name: row.Name, MimeType: mime, Size: fi.Size()}, nil
}
return ContentInfo{}, repository.ErrNotFound
}
// GetFileOcr returns the OCR text of a file the user can see (viewer+, own or
// shared). Absent text → Text empty ("") with 200 (the caller decides).
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
row, err := s.Repo.GetFileVisible(ownerID, id)
if err != nil {
return FileOcrDTO{}, err
}
return FileOcrDTO{
Text: row.OcrText,
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
}, nil
}
func (s *Resources) DeleteFile(ownerID, id string) (string, error) { func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
return s.Repo.DeleteFile(ownerID, id) return s.Repo.DeleteFile(ownerID, id)
} }
@@ -104,53 +250,174 @@ func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDT
// Upload persists the multipart-sourced file under UploadDir/<user> and // Upload persists the multipart-sourced file under UploadDir/<user> and
// records its metadata, returning the FileDTO. The physical file is removed // records its metadata, returning the FileDTO. The physical file is removed
// if metadata persistence fails (e.g. name conflict). // if metadata persistence fails (e.g. name conflict).
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID string) (FileDTO, error) { //
if file.Size > s.MaxFileSize { // When resourceID is non-empty the upload TARGETS an existing file owned by
return FileDTO{}, FileTooLargeError // the user (metadata-only resource from the outbox, or a previously uploaded
// file): the bytes are written under UploadDir/<user>/<resourceID>.<ext> and
// only the physical metadata (size/mime/extension) is refreshed — never a
// rename, never a move, never a duplicate row. Unknown / foreign resource →
// repo.ErrNotFound.
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
// Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des
// composants de chemin. ownerID vient de l'auth mais on ne lui fait pas
// confiance aveuglément ; resourceID fourni par le client est déjà
// pré-validé côté handler (404), ici on rejete en NotFound/400 pareil.
if strings.ContainsAny(ownerID, "/\\\x00\n\r") || strings.Contains(ownerID, "..") {
return FileDTO{}, ErrInvalidUpload
}
targetExisting := resourceID != ""
if targetExisting {
if !idPattern.MatchString(resourceID) {
return FileDTO{}, repository.ErrNotFound
}
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
return FileDTO{}, err
}
} else {
var err error
resourceID, err = repository.NewIDErr()
if err != nil {
return FileDTO{}, err
}
} }
id := repository.NewID() name, err := sanitizeFileName(file.Filename)
extension := strings.TrimPrefix(filepath.Ext(file.Filename), ".") if err != nil {
return FileDTO{}, err
}
extension := sanitizeExtension(file.Filename)
destDir := filepath.Join(s.UploadDir, ownerID) destDir := filepath.Join(s.UploadDir, ownerID)
if err := os.MkdirAll(destDir, 0o755); err != nil { if err := os.MkdirAll(destDir, 0o700); err != nil {
return FileDTO{}, fmt.Errorf("create upload dir: %w", err) return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
} }
// MkdirAll respecte umask et ne touche pas aux dirs préexistants : on
destPath := filepath.Join(destDir, id+"."+extension) // enforce 0700 explicitement (cf. FEEDBACK A4).
if err := copyMultipart(file, destPath); err != nil { if err := os.Chmod(destDir, 0o700); err != nil {
return FileDTO{}, err return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
} }
mimeType := file.Header.Get("Content-Type") destName := resourceID
if err := s.Repo.InsertFile(ownerID, id, file.Filename, folderID, file.Size, &mimeType, &extension); err != nil { if extension != "" {
_ = os.Remove(destPath) destName = resourceID + "." + extension
return FileDTO{}, err }
destPath := filepath.Join(destDir, destName)
// Mémorise les anciens physiques pour cleanup post-succès (changement d'ext).
// Note : Glob(id.*) ne matche pas le fichier sans extension, on traite le
// chemin nu séparément (cf. FEEDBACK #6).
oldMatches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
barePath := filepath.Join(destDir, resourceID)
if barePath != destPath {
if _, err := os.Stat(barePath); err == nil {
oldMatches = append(oldMatches, barePath)
}
} }
row, err := s.Repo.GetFile(ownerID, id) written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
if err != nil { if err != nil {
return FileDTO{}, err return FileDTO{}, err
} }
mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
var extPtr *string
if extension != "" {
extPtr = &extension
}
if targetExisting {
err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
} else {
err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr)
}
if err != nil {
// Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique.
stillOld := false
for _, m := range oldMatches {
if m == destPath {
stillOld = true
break
}
}
if !stillOld {
_ = os.Remove(destPath)
}
return FileDTO{}, err
}
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
for _, m := range oldMatches {
if m != destPath && strings.HasPrefix(filepath.Base(m), resourceID+".") {
_ = os.Remove(m)
}
}
row, err := s.Repo.GetFile(ownerID, resourceID)
if err != nil {
// Lecture post-insert en échec : au moins logguer (cf. FEEDBACK #6).
// Sur création on tente en plus de retirer le fichier pour ne pas
// laisser d'orphelin (le client retry → NAME_CONFLICT → re-upload
// ciblé). Sur re-upload ciblé on ne touche à rien (données existantes).
log.Printf("upload: GetFile(%s) failed after persist: %v", resourceID, err)
if !targetExisting {
_ = os.Remove(destPath)
}
return FileDTO{}, err
}
return toFileDTO(row), nil return toFileDTO(row), nil
} }
func copyMultipart(file *multipart.FileHeader, destPath string) error { // copyMultipartAtomic écrit vers un temp dans destDir (0600) avec limite
// stricte maxSize+1 (header file.Size non fiable, cf. A2), fsync + rename
// atomique (cf. A3). Retourne les octets réellement écrits.
func copyMultipartAtomic(file *multipart.FileHeader, destDir, destPath string, maxSize int64) (int64, error) {
src, err := file.Open() src, err := file.Open()
if err != nil { if err != nil {
return fmt.Errorf("open multipart file: %w", err) return 0, fmt.Errorf("open multipart file: %w", err)
} }
defer src.Close() defer src.Close()
dst, err := os.Create(destPath) // Temp dans le même répertoire (même filesystem → rename atomique),
// pattern .tmp-<base>-* (cf. FEEDBACK A3). Jamais d'overwrite direct.
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
if err != nil { if err != nil {
return fmt.Errorf("create file: %w", err) return 0, fmt.Errorf("create tmp file: %w", err)
}
tmpName := tmp.Name()
// En cas d'échec avant rename, nettoyer le temp.
success := false
defer func() {
if !success {
_ = os.Remove(tmpName)
}
}()
if err := tmp.Chmod(0o600); err != nil {
tmp.Close()
return 0, fmt.Errorf("chmod tmp file: %w", err)
} }
defer dst.Close()
if _, err := io.Copy(dst, src); err != nil { limited := io.LimitReader(src, maxSize+1)
return fmt.Errorf("copy upload: %w", err) written, err := io.Copy(tmp, limited)
if err != nil {
tmp.Close()
return 0, fmt.Errorf("copy upload: %w", err)
} }
return nil if written > maxSize {
tmp.Close()
return 0, ErrFileTooLarge
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return 0, fmt.Errorf("fsync upload: %w", err)
}
if err := tmp.Close(); err != nil {
return 0, fmt.Errorf("close upload: %w", err)
}
if err := os.Rename(tmpName, destPath); err != nil {
return 0, fmt.Errorf("commit upload: %w", err)
}
if err := os.Chmod(destPath, 0o600); err != nil {
return 0, fmt.Errorf("chmod upload: %w", err)
}
success = true
return written, nil
} }
func toFileDTO(row repository.FileRow) FileDTO { func toFileDTO(row repository.FileRow) FileDTO {
+277 -4
View File
@@ -6,9 +6,10 @@ import (
"mime/multipart" "mime/multipart"
"os" "os"
"path/filepath" "path/filepath"
"strings"
"testing" "testing"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
func multipartFileHeader(t *testing.T, filename string, content []byte) *multipart.FileHeader { func multipartFileHeader(t *testing.T, filename string, content []byte) *multipart.FileHeader {
@@ -42,7 +43,7 @@ func TestUploadPersistsPhysicalFile(t *testing.T) {
s := newServiceStore(t) s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-happy") userID := mustCreateUser(t, s.Repository, "upload-happy")
dto, err := s.Upload(userID, multipartFileHeader(t, "docs.txt", []byte("hello")), "") dto, err := s.Upload(userID, multipartFileHeader(t, "docs.txt", []byte("hello")), "", "")
if err != nil { if err != nil {
t.Fatalf("upload: %v", err) t.Fatalf("upload: %v", err)
} }
@@ -70,7 +71,7 @@ func TestUploadRemovesPhysicalFileOnNameConflict(t *testing.T) {
} }
target := multipartFileHeader(t, "dupe.txt", []byte("hello")) target := multipartFileHeader(t, "dupe.txt", []byte("hello"))
first, err := s.Upload(userID, target, folderID) first, err := s.Upload(userID, target, folderID, "")
if err != nil { if err != nil {
t.Fatalf("premier upload: %v", err) t.Fatalf("premier upload: %v", err)
} }
@@ -79,7 +80,7 @@ func TestUploadRemovesPhysicalFileOnNameConflict(t *testing.T) {
} }
// Même nom, même dossier → NAME_CONFLICT et pas de second fichier physique. // Même nom, même dossier → NAME_CONFLICT et pas de second fichier physique.
if _, err := s.Upload(userID, target, folderID); !errors.Is(err, repository.ErrNameConflict) { if _, err := s.Upload(userID, target, folderID, ""); !errors.Is(err, repository.ErrNameConflict) {
t.Fatalf("second upload : attendu ErrNameConflict, got %v", err) t.Fatalf("second upload : attendu ErrNameConflict, got %v", err)
} }
@@ -91,3 +92,275 @@ func TestUploadRemovesPhysicalFileOnNameConflict(t *testing.T) {
t.Errorf("fichier orphelin laissé après NAME_CONFLICT : %d fichiers", len(entries)) t.Errorf("fichier orphelin laissé après NAME_CONFLICT : %d fichiers", len(entries))
} }
} }
func TestUploadTargetsExistingResource(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-target")
// Fiche metadata-only créée par l'outbox côté client.
resourceID := repository.NewID()
ext := "png"
if err := s.Repository.Resources.InsertFile(userID, resourceID, "scan.png", "", 0, nil, &ext); err != nil {
t.Fatalf("insert metadata-only file: %v", err)
}
// Re-upload ciblé : mêmes octets, même resource_id, pas de doublon.
dto, err := s.Upload(userID, multipartFileHeader(t, "scan.png", []byte("PNGDATA")), "", resourceID)
if err != nil {
t.Fatalf("targeted upload: %v", err)
}
if dto.ID != resourceID {
t.Errorf("id attendu %s, got %s", resourceID, dto.ID)
}
if dto.Size != 7 {
t.Errorf("taille = %d, attendu 7 (rafraîchie)", dto.Size)
}
path := filepath.Join(s.UploadDir, userID, resourceID+".png")
info, err := os.Stat(path)
if err != nil {
t.Fatalf("fichier physique absent: %v", err)
}
if info.Size() != 7 {
t.Errorf("taille physique = %d, attendu 7", info.Size())
}
// Une seule ligne serveur (pas de doublon créé par le re-upload).
rows, total, err := s.Repo.ListFiles(userID, "", 50, 0, "", "")
if err != nil {
t.Fatalf("list: %v", err)
}
if total != 1 || len(rows) != 1 || rows[0].ID != resourceID {
t.Errorf("liste après re-upload: total=%d rows=%+v", total, rows)
}
}
func TestUploadTargetsOwnedResourceOnly(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-owner")
otherUser := mustCreateUser(t, s.Repository, "upload-owner-other")
resourceID := repository.NewID()
if err := s.Repository.Resources.InsertFile(otherUser, resourceID, "mine.png", "", 0, nil, nil); err != nil {
t.Fatalf("insert other's file: %v", err)
}
// Un resource_id d'un autre user → ErrNotFound, aucun octet écrit.
if _, err := s.Upload(userID, multipartFileHeader(t, "mine.png", []byte("DATA")), "", resourceID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("upload cross-user : attendu ErrNotFound, got %v", err)
}
// Le dossier upload du user ne doit pas avoir été créé (échec avant écriture).
if _, err := os.Stat(filepath.Join(s.UploadDir, userID)); !os.IsNotExist(err) {
t.Errorf("dossier upload créé à tort ou erreur inattendue: %v", err)
}
}
func TestUploadTargetUnknownIsNotFound(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-unknown")
if _, err := s.Upload(userID, multipartFileHeader(t, "ghost.png", []byte("DATA")), "", repository.NewID()); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("upload inconnu : attendu ErrNotFound, got %v", err)
}
}
// A2 : le header multipart Size est déclaratif — seul le comptage réel des
// octets (LimitReader MaxFileSize+1) fait foi.
func TestUploadEnforcesActualSizeDespiteLyingHeader(t *testing.T) {
s := newServiceStore(t) // MaxFileSize = 100
userID := mustCreateUser(t, s.Repository, "upload-lying")
fh := multipartFileHeader(t, "big.txt", bytes.Repeat([]byte("x"), 150))
fh.Size = 10 // header menteur : annonce 10 alors que 150 arrivent
if _, err := s.Upload(userID, fh, "", ""); !errors.Is(err, ErrFileTooLarge) {
t.Fatalf("header menteur : attendu ErrFileTooLarge, got %v", err)
}
// Aucun résidu physique (ni fichier final, ni .tmp-* orphelin).
if entries, err := os.ReadDir(filepath.Join(s.UploadDir, userID)); err == nil && len(entries) != 0 {
names := make([]string, 0, len(entries))
for _, e := range entries {
names = append(names, e.Name())
}
t.Errorf("résidu physique après refus : %v", names)
}
}
// #5 : extension sanitizée (lowercase [a-z0-9]{1,10}), pas de "id." si vide.
func TestUploadSanitizesExtension(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-ext")
// Uppercase → lowercase.
dto, err := s.Upload(userID, multipartFileHeader(t, "PHOTO.JPG", []byte("data")), "", "")
if err != nil {
t.Fatalf("upload uppercase ext: %v", err)
}
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto.ID+".jpg")); err != nil {
t.Errorf("fichier .jpg (lowercase) attendu: %v", err)
}
// Pas d'extension → fichier nu, sans trailing dot.
dto2, err := s.Upload(userID, multipartFileHeader(t, "README", []byte("data")), "", "")
if err != nil {
t.Fatalf("upload sans ext: %v", err)
}
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto2.ID)); err != nil {
t.Errorf("fichier sans extension attendu: %v", err)
}
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto2.ID+".")); !os.IsNotExist(err) {
t.Errorf("trailing dot interdit (id.) : err=%v", err)
}
// Extension trop longue / non alnum → "" (fichier nu).
dto3, err := s.Upload(userID, multipartFileHeader(t, "run.verylongextensiontoolong", []byte("data")), "", "")
if err != nil {
t.Fatalf("upload ext invalide: %v", err)
}
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto3.ID)); err != nil {
t.Errorf("ext invalide → fichier nu attendu: %v", err)
}
// Backslash survit au round-trip multipart stdlib → rejet prouvé de bout
// en bout (les autres cas slash/NUL/retour-ligne sont couverts en
// unitaire sur sanitizeFileName, la stdlib Go les neutralisant déjà).
if _, err := s.Upload(userID, multipartFileHeader(t, `a\b.txt`, []byte("data")), "", ""); !errors.Is(err, ErrInvalidUpload) {
t.Errorf(`nom %q : attendu ErrInvalidUpload, got %v`, `a\b.txt`, err)
}
}
// #5/A16 : sanitizeurs unitaires — un client non-Go peut envoyer un filename
// brut (slash, .., NUL, retour-ligne) que la stdlib Go ne neutraliserait pas
// côté lecture serveur.
func TestSanitizeFileName(t *testing.T) {
for _, bad := range []string{"", " ", "../evil.txt", "a/b.txt", "a\x00b.txt", "bad\nname.txt", "bad\rname.txt", strings.Repeat("a", 256)} {
if _, err := sanitizeFileName(bad); !errors.Is(err, ErrInvalidUpload) {
t.Errorf("sanitizeFileName(%q) : attendu ErrInvalidUpload, got %v", bad, err)
}
}
for _, good := range []string{"docs.txt", " pad.txt ", "vacances-août.jpg", "a b c.pdf"} {
got, err := sanitizeFileName(good)
if err != nil {
t.Errorf("sanitizeFileName(%q) : rejet inattendu: %v", good, err)
} else if got != strings.TrimSpace(good) {
t.Errorf("sanitizeFileName(%q) = %q, attendu trim", good, got)
}
}
}
func TestSanitizeExtension(t *testing.T) {
cases := map[string]string{
"photo.JPG": "jpg",
"archive.tar.gz": "gz",
"README": "",
"run.verylongextensiontoolong": "",
"evil.php/../../x": "",
"a.b/c": "",
"weird.HTM\nL": "",
"dot.": "",
}
for in, want := range cases {
if got := sanitizeExtension(in); got != want {
t.Errorf("sanitizeExtension(%q) = %q, attendu %q", in, got, want)
}
}
}
// #6 : un re-upload ciblé avec une nouvelle extension ne laisse qu'un seul
// fichier physique (l'ancien suffixe est supprimé).
func TestUploadReuploadNewExtensionRemovesStaleFile(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-reext")
resourceID := repository.NewID()
png := "png"
if err := s.Repository.Resources.InsertFile(userID, resourceID, "scan.png", "", 0, nil, &png); err != nil {
t.Fatalf("insert metadata-only: %v", err)
}
if _, err := s.Upload(userID, multipartFileHeader(t, "scan.png", []byte("PNGDATA")), "", resourceID); err != nil {
t.Fatalf("premier upload ciblé: %v", err)
}
dto, err := s.Upload(userID, multipartFileHeader(t, "scan.jpg", []byte("JPGDATA!")), "", resourceID)
if err != nil {
t.Fatalf("re-upload nouvelle ext: %v", err)
}
if dto.ID != resourceID {
t.Fatalf("id attendu %s, got %s", resourceID, dto.ID)
}
entries, err := os.ReadDir(filepath.Join(s.UploadDir, userID))
if err != nil {
t.Fatalf("readdir: %v", err)
}
if len(entries) != 1 || entries[0].Name() != resourceID+".jpg" {
names := make([]string, 0, len(entries))
for _, e := range entries {
names = append(names, e.Name())
}
t.Errorf("un seul physique attendu (%s.jpg), got %v", resourceID, names)
}
content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg"))
if err != nil || string(content) != "JPGDATA!" {
t.Errorf("contenu = %q, err=%v (attendu JPGDATA!)", content, err)
}
}
// A4 : répertoire 0700, fichier 0600 (enforcés malgré umask).
func TestUploadFileAndDirPermissions(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-perms")
dto, err := s.Upload(userID, multipartFileHeader(t, "secret.txt", []byte("data")), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
dirInfo, err := os.Stat(filepath.Join(s.UploadDir, userID))
if err != nil {
t.Fatalf("stat dir: %v", err)
}
if perm := dirInfo.Mode().Perm(); perm != 0o700 {
t.Errorf("perms dossier = %04o, attendu 0700", perm)
}
fileInfo, err := os.Stat(filepath.Join(s.UploadDir, userID, dto.ID+".txt"))
if err != nil {
t.Fatalf("stat file: %v", err)
}
if perm := fileInfo.Mode().Perm(); perm != 0o600 {
t.Errorf("perms fichier = %04o, attendu 0600", perm)
}
}
// A16 : Content-Type hors whitelist → fallback application/octet-stream.
func TestUploadMimeTypeWhitelistFallback(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "upload-mime")
evil := multipartFileHeader(t, "evil.bin", []byte("data"))
evil.Header.Set("Content-Type", "application/x-evil-tool")
dto, err := s.Upload(userID, evil, "", "")
if err != nil {
t.Fatalf("upload evil mime: %v", err)
}
if dto.MimeType != "application/octet-stream" {
t.Errorf("mime inattendu = %q, attendu fallback application/octet-stream", dto.MimeType)
}
withParams := multipartFileHeader(t, "page.bin", []byte("data"))
withParams.Header.Set("Content-Type", "text/html; charset=utf-8")
dto, err = s.Upload(userID, withParams, "", "")
if err != nil {
t.Fatalf("upload html mime: %v", err)
}
if dto.MimeType != "application/octet-stream" {
t.Errorf("text/html non whitelisté, fallback attendu, got %q", dto.MimeType)
}
allowed := multipartFileHeader(t, "img.bin", []byte("data"))
allowed.Header.Set("Content-Type", "image/png")
dto, err = s.Upload(userID, allowed, "", "")
if err != nil {
t.Fatalf("upload png mime: %v", err)
}
if dto.MimeType != "image/png" {
t.Errorf("mime whitelisté perdu, got %q", dto.MimeType)
}
}
+4 -29
View File
@@ -1,31 +1,6 @@
package service package service
import "github.com/vaultdrop/backend/models" // Stubs historiques UserCan* (toujours-true) supprimés — LOT 5 #11.
// L'autorisation V1 est portée par le scoping owner (`user_id`) dans
type Services struct { // repository.Resources + les grants `shares` (cf. docs/api-v1.md) :
ConnectedUser *models.User // aucune fonction toujours-true ne doit subsister ici.
}
func New(connectedUser *models.User) *Services {
return &Services{
ConnectedUser: connectedUser,
}
}
func UserCanReadDocument(connectedUser *models.User, document *models.Document) (bool, string) {
return true, ""
}
func UserCanEditDocument(connectedUser *models.User, document *models.Document) (bool, string) {
return true, ""
}
func UserCanDeleteDocument(connectedUser *models.User, document *models.Document) (bool, string) {
return true, ""
}
func UserCanCreateDocument(connectedUser *models.User, document *models.Document) (bool, string) {
return true, ""
}
+98
View File
@@ -0,0 +1,98 @@
package service
import (
"time"
"github.com/kazier/backend/repository"
)
// ShareGrantDTO serializes one active grant for GET /files/:id/shares.
// Milliseconds epoch (null = never), mirroring the permissions snapshot
// (docs/api-v1.md §6.2) for cheap client-side expiry checks.
type ShareGrantDTO struct {
GranteeUserID string `json:"granteeUserId"`
Username string `json:"username"`
Access string `json:"access"`
Inherit bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
UpdatedAt int64 `json:"updatedAt"`
}
// LinkDTO serializes one active public link for GET /files/:id/links —
// same shape as the public GET /shares/links/:token resolution.
type LinkDTO struct {
Token string `json:"token"`
ResourceID string `json:"resource_id"`
ResourceType string `json:"resourceType"`
Name string `json:"name"`
Access string `json:"access"`
ExpiresAt *string `json:"expiresAt"`
}
// ListShares returns the active grants on a resource the user OWNS.
// Non-owner (or unknown resource) → repository.ErrNotFound (no enumeration,
// same scoping as the share outbox ops).
func (s *Resources) ListShares(userID, resourceID string) ([]ShareGrantDTO, error) {
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return nil, err
}
if ownerID != userID {
return nil, repository.ErrNotFound
}
grants, err := s.Repository.Shares.ListActiveForResource(resourceID)
if err != nil {
return nil, err
}
out := make([]ShareGrantDTO, 0, len(grants))
for _, g := range grants {
var expires *int64
if g.ExpiresAt != nil {
ms := g.ExpiresAt.UnixMilli()
expires = &ms
}
out = append(out, ShareGrantDTO{
GranteeUserID: g.GranteeUserID,
Username: g.Username,
Access: g.Access,
Inherit: g.Inherit,
ExpiresAt: expires,
UpdatedAt: g.UpdatedAt.UnixMilli(),
})
}
return out, nil
}
// ListLinks returns the active public links of a resource the user OWNS.
// Same owner-only scoping as ListShares.
func (s *Resources) ListLinks(userID, resourceID string) ([]LinkDTO, error) {
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return nil, err
}
if ownerID != userID {
return nil, repository.ErrNotFound
}
links, err := s.Repository.Shares.ListActiveLinksForResource(resourceID)
if err != nil {
return nil, err
}
out := make([]LinkDTO, 0, len(links))
for _, l := range links {
var expires *string
if l.ExpiresAt != nil {
// Même forme que ShareLinkGet (time.Time marshaled en RFC3339).
str := l.ExpiresAt.UTC().Format(time.RFC3339)
expires = &str
}
out = append(out, LinkDTO{
Token: l.Token,
ResourceID: l.ResourceID,
ResourceType: l.ResourceType,
Name: l.Name,
Access: l.Access,
ExpiresAt: expires,
})
}
return out, nil
}
+169 -36
View File
@@ -3,10 +3,11 @@ package service
import ( import (
"encoding/json" "encoding/json"
"errors" "errors"
"log"
"regexp" "regexp"
"time" "time"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
var resourceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`) var resourceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
@@ -92,33 +93,86 @@ func classifySyncError(err error) (string, string) {
return "NOT_FOUND", "target resource or folder not found" return "NOT_FOUND", "target resource or folder not found"
case errors.Is(err, repository.ErrGranteeNotFound): case errors.Is(err, repository.ErrGranteeNotFound):
return "GRANTEE_NOT_FOUND", "the specified user does not exist" return "GRANTEE_NOT_FOUND", "the specified user does not exist"
case errors.Is(err, repository.ErrPayloadMismatch):
return "INVALID_REQUEST", "operation replayed with different payload"
case errors.Is(err, errCycle):
return "INVALID_REQUEST", "cannot move a resource into its own subtree"
default: default:
return "INVALID_REQUEST", err.Error() // Volontairement générique : ne pas fuir SQL/FS internes (cf. #8).
// Le détail reste côté serveur (logs), le client reçoit un code stable.
log.Printf("sync: internal apply error: %v", err)
return "INVALID_REQUEST", "invalid operation"
} }
} }
var errCycle = errors.New("cannot move a resource into its own subtree")
// ApplyBatch applique les ops de l'outbox : les mutations de ressources sont // ApplyBatch applique les ops de l'outbox : les mutations de ressources sont
// scopées par l'UTILISATEUR (userID), l'idempotence reste par DEVICE // scopées par l'UTILISATEUR (userID), l'idempotence reste par DEVICE
// (deviceID) — cf. docs/api-v1.md §6.1. // (deviceID) — cf. docs/api-v1.md §6.1.
//
// Atomicité par op (#7) : chaque op est sérialisée par un claim atomique sur
// la trace outbox (INSERT ... ON CONFLICT DO NOTHING portant la contrainte
// UNIQUE(device_id, operation_id), cf. Operations.Claim) — deux batches
// concurrents ne peuvent pas appliquer deux fois la même op : le perdant
// suit le chemin rejeu (comparaison de hash, cf. A9). Le claim est posé en
// status='failed' AVANT l'apply puis promu en 'applied' (MarkApplied) une
// fois l'effet durable : un crash entre les deux laisse une trace rejouable
// (ré-apply à payload identique), jamais un skip silencieux.
//
// Limite documentée : claim→apply→promote ne sont pas une transaction SQL
// unique — apply touche resources/shares via des statements atomiques
// (INSERT ... SELECT parent, TouchOwned). Le TOCTOU résiduel (deux owners
// créant le même resource_id) dégénère en NAME_CONFLICT explicite, jamais
// en double écriture silencieuse. Une atomicité totale exigerait un
// transaction manager transverse aux repos (vrai Tx ApplyBatch, reportée —
// cf. FEEDBACK risques résiduels).
//
// Erreurs de persistance (claim/promote) : retournées comme applied:i
// explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client
// sait exactement où reprendre.
func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) { func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) {
for i := range ops { for i := range ops {
op := &ops[i] op := &ops[i]
if err := validateSyncOp(op); err != nil { if err := validateSyncOp(op); err != nil {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil
} }
already, err := s.Repository.Operations.Applied(deviceID, op.OperationID) claimed, err := s.Repository.Operations.Claim(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload)
if err != nil { if err != nil {
return SyncResult{}, err // Faute client (clé ou payload malformé) → INVALID_REQUEST halt,
// message statique sûr ; panne persistance → INTERNAL explicite.
if errors.Is(err, repository.ErrInvalidOperationID) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation_id must be 32 lowercase hex chars"}}, nil
}
if errors.Is(err, repository.ErrInvalidPayload) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil
}
log.Printf("sync: claim device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to persist operation state"}}, nil
} }
if already { if !claimed {
continue // Rejeu : même (device, op) déjà tracé — comparer (A9).
stored, err := s.Repository.Operations.Get(deviceID, op.OperationID)
if err != nil {
log.Printf("sync: replay read device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to read operation state"}}, nil
}
if err := stored.MatchesReplay(op.Operation, derefString(op.ResourceID), op.Payload); err != nil {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation replayed with different payload"}}, nil
}
if stored.Status == repository.OpStatusApplied {
continue // déjà appliquée à l'identique → skip idempotent
}
// Trace 'failed' à payload identique : la première tentative est
// morte avant MarkApplied (crash) → on ré-applique (recovery).
} }
if err := s.applySyncOp(userID, op); err != nil { if err := s.applySyncOp(userID, op); err != nil {
code, message := classifySyncError(err) code, message := classifySyncError(err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil
} }
if err := s.recordApplied(deviceID, op); err != nil { if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil {
return SyncResult{}, err log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "operation applied but trace update failed; safe to retry"}}, nil
} }
} }
return SyncResult{Applied: len(ops)}, nil return SyncResult{Applied: len(ops)}, nil
@@ -167,29 +221,47 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
// Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon, // Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon,
// cohérent avec move_resource). Ordre du SAF walk : parent avant enfant. // cohérent avec move_resource). Ordre du SAF walk : parent avant enfant.
if p.ParentResourceID != "" { if p.ParentResourceID != "" {
if !resourceIDPattern.MatchString(p.ParentResourceID) {
return errors.New("payload.parentResourceId must be 32 lowercase hex chars")
}
if _, err := s.Repo.GetFolder(ownerID, p.ParentResourceID); err != nil { if _, err := s.Repo.GetFolder(ownerID, p.ParentResourceID); err != nil {
return err return err
} }
} }
var insertErr error
if derefString(op.ResourceType) == "folder" { if derefString(op.ResourceType) == "folder" {
return s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID) insertErr = s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID)
} else {
mime := p.MimeType
insertErr = s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension))
} }
mime := p.MimeType if insertErr != nil {
return s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension)) // Course ExistsOwner→Insert (concurrent ou rejeu croisé) : si la
// ressource est désormais owned, l'effet est atteint → idempotent.
// Sinon NAME_CONFLICT explicite (sibling ou resource_id d'autrui).
// Atomicité totale (INSERT ... SELECT) : inter-lots, LOT 4.
if errors.Is(insertErr, repository.ErrNameConflict) {
if owned, err := s.Repo.ExistsOwner(ownerID, resourceID); err == nil && owned {
return nil
}
}
return insertErr
}
return nil
case OpUpdateMetadata: case OpUpdateMetadata:
// Owner can always rename. A shared resource can be renamed by an // Sémantique uniforme (A8) : toute ressource que l'appelant ne peut
// editor+ (docs §6.2 effective_access ranking). Below editor, or on // pas renommer — absente, d'autrui, ou partagée sous editor — halte
// a resource the caller cannot reach at all, we keep the documented // en NOT_FOUND. Pas de no-op silencieux : un rename qui n'a rien
// terminal-state semantics: absent → no-op. // renommé est un bug client ou une désync, le halt l'expose au lieu
// de valider un état qui n'existe pas. Le même code NOT_FOUND dans
// tous les cas évite tout oracle d'existence. Owner → rank owner,
// editor+ partagé → autorisé (docs §6.2).
access, err := s.Repository.Shares.EffectiveAccess(ownerID, resourceID) access, err := s.Repository.Shares.EffectiveAccess(ownerID, resourceID)
if err != nil { if err != nil {
return err return err
} }
if access.EffectiveRank < repository.AccessEditor { if access.EffectiveRank < repository.AccessEditor {
if !access.Accessible {
return nil
}
return repository.ErrNotFound return repository.ErrNotFound
} }
var p renamePayload var p renamePayload
@@ -199,16 +271,17 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
if p.Name == "" { if p.Name == "" {
return errors.New("payload.name required") return errors.New("payload.name required")
} }
return s.Repo.UpdateNameByID(resourceID, p.Name) // NOTE : UpdateNameByID (non-scopé) est volontaire ici — un editor
// non-owner peut renommer (EffectiveAccess vérifié plus haut), donc
// UpdateNameOwned(ownerID, ...) rejetterait à tort. La garde
// d'autorisation précède immédiatement l'écriture.
return s.Repo.UpdateNameByID(resourceID, p.Name)
case OpMoveResource: case OpMoveResource:
exists, err := s.Repo.ExistsOwner(ownerID, resourceID) // A8 : move owner-only. Source non-owned (absente OU d'autrui) →
if err != nil { // NOT_FOUND halt (MoveResource ne touche que les lignes owned).
return err // Pas de applied silencieux : un move qui n'a rien déplacé
} // désynchroniserait le client.
if !exists {
return nil
}
var p movePayload var p movePayload
if err := json.Unmarshal(op.Payload, &p); err != nil { if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error()) return errors.New("invalid payload: " + err.Error())
@@ -216,9 +289,36 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
if p.ToFolderResourceID == resourceID { if p.ToFolderResourceID == resourceID {
return errors.New("cannot move a resource into itself") return errors.New("cannot move a resource into itself")
} }
if p.ToFolderResourceID != "" {
if !resourceIDPattern.MatchString(p.ToFolderResourceID) {
return errors.New("payload.toFolderResourceId must be 32 lowercase hex chars")
}
// Check de cycle : le dossier cible ne doit pas être la ressource
// elle-même ni l'un de ses descendants (cf. FEEDBACK #2).
if err := s.checkNoCycle(p.ToFolderResourceID, resourceID); err != nil {
return err
}
}
return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID) return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID)
case OpDeleteResource: case OpDeleteResource:
// A8 : delete owner-only. Ligne vivante d'autrui → NOT_FOUND halt
// (pas de applied silencieux). Aucune ligne vivante (jamais existé,
// ou déjà supprimée par son owner) → no-op idempotent : l'état
// terminal (absente) est déjà atteint, le rejeu reste sûr.
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if !exists {
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil
}
return err
}
return repository.ErrNotFound
}
return s.Repo.SyncDelete(ownerID, resourceID) return s.Repo.SyncDelete(ownerID, resourceID)
case OpShare, OpUpdateShare: case OpShare, OpUpdateShare:
@@ -275,13 +375,18 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
var expiresAt *time.Time var expiresAt *time.Time
if p.ExpiresAt != nil { if p.ExpiresAt != nil {
t := time.UnixMilli(*p.ExpiresAt) t := time.UnixMilli(*p.ExpiresAt)
if !t.After(time.Now()) {
return errors.New("payload.expiresAt must be in the future")
}
expiresAt = &t expiresAt = &t
} }
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil { if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err return err
} }
// Bump resource updated_at so the grantee's delta snapshot picks it up. // Bump resource updated_at so the grantee's delta snapshot picks it up.
return s.Repo.TouchResource(resourceID) // Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le
// TouchResource non-scopé.
return s.Repo.TouchOwned(ownerID, resourceID)
} }
// applyRevokeShareOp handles OpRevokeShare: soft-revoke a user-to-user grant. // applyRevokeShareOp handles OpRevokeShare: soft-revoke a user-to-user grant.
@@ -303,10 +408,13 @@ func (s *Resources) applyRevokeShareOp(ownerID, resourceID string, op *SyncOpera
if !resourceIDPattern.MatchString(p.GranteeUserID) { if !resourceIDPattern.MatchString(p.GranteeUserID) {
return errors.New("payload.granteeUserId must be 32 lowercase hex chars") return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
} }
// Revoke is idempotent: no-op if already revoked/missing. // Revoke is idempotent: no-op if already revoked/missing — mais les vraies
_ = s.Repository.Shares.Revoke(resourceID, p.GranteeUserID) // pannes DB remontent (cf. FEEDBACK §moyenne).
if err := s.Repository.Shares.Revoke(resourceID, p.GranteeUserID); err != nil && !errors.Is(err, repository.ErrNotFound) {
return err
}
// Bump resource updated_at so the grantee's delta snapshot reflects the change. // Bump resource updated_at so the grantee's delta snapshot reflects the change.
return s.Repo.TouchResource(resourceID) return s.Repo.TouchOwned(ownerID, resourceID)
} }
// applyCreateLinkOp handles OpCreateLink: create a public share link. // applyCreateLinkOp handles OpCreateLink: create a public share link.
@@ -332,12 +440,15 @@ func (s *Resources) applyCreateLinkOp(ownerID, resourceID string, op *SyncOperat
var expiresAt *time.Time var expiresAt *time.Time
if p.ExpiresAt != nil { if p.ExpiresAt != nil {
t := time.UnixMilli(*p.ExpiresAt) t := time.UnixMilli(*p.ExpiresAt)
if !t.After(time.Now()) {
return errors.New("payload.expiresAt must be in the future")
}
expiresAt = &t expiresAt = &t
} }
if err := s.Repository.Shares.CreateLink(p.Token, resourceID, p.Access, expiresAt, ownerID); err != nil { if err := s.Repository.Shares.CreateLink(p.Token, resourceID, p.Access, expiresAt, ownerID); err != nil {
return err return err
} }
return s.Repo.TouchResource(resourceID) return s.Repo.TouchOwned(ownerID, resourceID)
} }
// applyRevokeLinkOp handles OpRevokeLink: soft-revoke a public share link. // applyRevokeLinkOp handles OpRevokeLink: soft-revoke a public share link.
@@ -356,13 +467,35 @@ func (s *Resources) applyRevokeLinkOp(ownerID, resourceID string, op *SyncOperat
if !resourceIDPattern.MatchString(p.Token) { if !resourceIDPattern.MatchString(p.Token) {
return errors.New("payload.token must be 32 lowercase hex chars") return errors.New("payload.token must be 32 lowercase hex chars")
} }
// Revoke is idempotent: no-op if already revoked/missing. // Revoke is idempotent: no-op if already revoked/missing — mais les vraies
_ = s.Repository.Shares.RevokeLink(p.Token) // pannes DB remontent.
return s.Repo.TouchResource(resourceID) if err := s.Repository.Shares.RevokeLink(p.Token); err != nil && !errors.Is(err, repository.ErrNotFound) {
return err
}
return s.Repo.TouchOwned(ownerID, resourceID)
} }
func (s *Resources) recordApplied(deviceID string, op *SyncOperation) error { // checkNoCycle remonte la chaîne parentale depuis toFolder : si on rencontre
return s.Repository.Operations.Record(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload) // resourceID, le move créerait un cycle (cf. FEEDBACK #2).
func (s *Resources) checkNoCycle(toFolderID, resourceID string) error {
cur := toFolderID
for i := 0; i < 128; i++ {
if cur == "" {
return nil
}
if cur == resourceID {
return errCycle
}
parent, err := s.Repo.GetParentID(cur)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return err
}
return err
}
cur = parent
}
return errCycle
} }
func derefString(v *string) string { func derefString(v *string) string {
+286 -12
View File
@@ -6,11 +6,11 @@ import (
"testing" "testing"
"time" "time"
"github.com/vaultdrop/backend/dbtest" "github.com/kazier/backend/dbtest"
"github.com/vaultdrop/backend/repository" "github.com/kazier/backend/repository"
) )
const serviceTestURL = "postgres://vaultdrop:vaultdrop@localhost:5432/vaultdrop_service_test?sslmode=disable" const serviceTestURL = "postgres://kazier:kazier@localhost:5432/kazier_service_test?sslmode=disable"
// newServiceStore returns a Resources service over a fresh migrated test DB. // newServiceStore returns a Resources service over a fresh migrated test DB.
func newServiceStore(t *testing.T) *Resources { func newServiceStore(t *testing.T) *Resources {
@@ -208,6 +208,41 @@ func TestApplyBatchMoveToMissingFolder(t *testing.T) {
} }
} }
func TestApplyBatchMoveIntoDescendantRejected(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "sync-move-cycle")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
parentID := repository.NewID()
childID := repository.NewID()
if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
syncOp(repository.NewID(), parentID, OpCreateResource, "folder", map[string]any{"name": "parent"}),
syncOp(repository.NewID(), childID, OpCreateResource, "folder", map[string]any{"name": "child", "parentResourceId": parentID}),
}); err != nil {
t.Fatalf("apply create parent+child: %v", err)
}
// Déplacer le parent dans son propre enfant créerait un cycle : halt.
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
syncOp(repository.NewID(), parentID, OpMoveResource, "folder", map[string]any{"toFolderResourceId": childID}),
})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" {
t.Fatalf("move parent→enfant: attendu applied=0 INVALID_REQUEST, got %+v", result)
}
// Le parent est toujours à la racine : aucun cycle créé.
got, err := s.Repository.Resources.GetParentID(parentID)
if err != nil {
t.Fatalf("GetParentID: %v", err)
}
if got != "" {
t.Errorf("parent déplacé malgré le rejet: parent=%q", got)
}
}
func TestApplyBatchRejectsInvalidPayloadJSON(t *testing.T) { func TestApplyBatchRejectsInvalidPayloadJSON(t *testing.T) {
s := newServiceStore(t) s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "sync-badpayload") userID := mustCreateUser(t, s.Repository, "sync-badpayload")
@@ -1146,15 +1181,16 @@ func TestUpdateMetadataRequiresEditor(t *testing.T) {
t.Errorf("viewer update: attendu applied=0 NOT_FOUND, got %+v", result) t.Errorf("viewer update: attendu applied=0 NOT_FOUND, got %+v", result)
} }
// Stranger (no access) → no-op terminal (absent semantics), no failure. // Stranger (no access) → NOT_FOUND halt (A8 : pas de no-op silencieux ;
// un rename qui n'a rien renommé est une désync, le halt l'expose).
result, err = s.ApplyBatch(strangerID, shareTestDeviceID, []SyncOperation{ result, err = s.ApplyBatch(strangerID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "sneak.txt"}), syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "sneak.txt"}),
}) })
if err != nil { if err != nil {
t.Fatalf("stranger update: %v", err) t.Fatalf("stranger update: %v", err)
} }
if result.Applied != 1 || result.Failed != nil { if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Errorf("stranger update: attendu applied=1 aucun échec, got %+v", result) t.Errorf("stranger update: attendu applied=0 NOT_FOUND, got %+v", result)
} }
row, err = s.Repo.GetFile(ownerID, fileID) row, err = s.Repo.GetFile(ownerID, fileID)
if err != nil || row.Name != "renamed.txt" { if err != nil || row.Name != "renamed.txt" {
@@ -1179,15 +1215,16 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) {
t.Fatalf("create + share: %v", err) t.Fatalf("create + share: %v", err)
} }
// Editor tries to move the shared file → no-op (owner-only), nothing moves. // Editor tries to move the shared file → NOT_FOUND halt (A8 : move
// owner-only, pas de applied silencieux).
result, err := s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{ result, err := s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}), syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}),
}) })
if err != nil { if err != nil {
t.Fatalf("grantee move: %v", err) t.Fatalf("grantee move: %v", err)
} }
if result.Applied != 1 || result.Failed != nil { if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Fatalf("grantee move: applied=%d failed=%+v", result.Applied, result.Failed) t.Fatalf("grantee move: attendu applied=0 NOT_FOUND, got %+v", result)
} }
row, err := s.Repo.GetFile(ownerID, fileID) row, err := s.Repo.GetFile(ownerID, fileID)
if err != nil { if err != nil {
@@ -1197,17 +1234,254 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) {
t.Errorf("fichier déplacé par un non-owner: folderId=%q, attendu racine", row.FolderID) t.Errorf("fichier déplacé par un non-owner: folderId=%q, attendu racine", row.FolderID)
} }
// Editor tries to delete the shared file → no-op, still present for owner. // Editor tries to delete the shared file → NOT_FOUND halt (A8), still
// present for owner.
result, err = s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{ result, err = s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}), syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
}) })
if err != nil { if err != nil {
t.Fatalf("grantee delete: %v", err) t.Fatalf("grantee delete: %v", err)
} }
if result.Applied != 1 || result.Failed != nil { if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Fatalf("grantee delete: applied=%d failed=%+v", result.Applied, result.Failed) t.Fatalf("grantee delete: attendu applied=0 NOT_FOUND, got %+v", result)
} }
if _, err := s.Repo.GetFile(ownerID, fileID); err != nil { if _, err := s.Repo.GetFile(ownerID, fileID); err != nil {
t.Errorf("fichier supprimé par un non-owner: %v", err) t.Errorf("fichier supprimé par un non-owner: %v", err)
} }
} }
// --- LOT 3 : rejeu, payload_hash, liens idempotents, sémantiques A8 ---
func TestApplyBatchReplaySameOpIsIdempotent(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "replay-owner")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
opID := repository.NewID()
op := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"})
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{op})
if err != nil || result.Applied != 1 || result.Failed != nil {
t.Fatalf("apply 1: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
// Rejeu à l'identique (même operation_id, même payload) → skip succès.
result, err = s.ApplyBatch(userID, deviceID, []SyncOperation{op})
if err != nil || result.Applied != 1 || result.Failed != nil {
t.Errorf("rejeu identique: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
}
func TestApplyBatchReplayMutatedPayloadRejected(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "replay-mut")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
opID := repository.NewID()
first := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"})
if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{first}); err != nil {
t.Fatalf("apply 1: %v", err)
}
// Même (device, operation_id), payload muté → INVALID_REQUEST halt (A9),
// pas de skip silencieux.
mutated := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "y.txt"})
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{mutated})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" {
t.Errorf("payload muté: attendu applied=0 INVALID_REQUEST, got %+v", result)
}
// Même opération rejouée sous un autre type → rejet aussi.
retyped := syncOp(opID, fileID, OpDeleteResource, "file", map[string]any{})
result, err = s.ApplyBatch(userID, deviceID, []SyncOperation{retyped})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" {
t.Errorf("type muté: attendu applied=0 INVALID_REQUEST, got %+v", result)
}
}
func TestApplyBatchReplayWhitespaceEquivalentPayload(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "replay-ws")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
opID := repository.NewID()
first := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"})
if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{first}); err != nil {
t.Fatalf("apply 1: %v", err)
}
// Même objet, sérialisation différente (espaces) → hash canonique égal → skip.
second := SyncOperation{
OperationID: opID,
ResourceID: strp(fileID),
ResourceType: strp("file"),
Operation: OpCreateResource,
Payload: json.RawMessage(`{ "name" : "x.txt" }`),
}
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{second})
if err != nil || result.Applied != 1 || result.Failed != nil {
t.Errorf("rejeu équivalent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
}
func TestCreateLinkReplayIdempotent(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "linkreplay-owner")
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}),
}); err != nil {
t.Fatalf("create: %v", err)
}
token := repository.NewID()
link := func(opID string) SyncOperation {
return syncOp(opID, fileID, OpCreateLink, "file", map[string]any{
"token": token,
"access": "viewer",
})
}
// Premier create_link.
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{link(repository.NewID())}); err != nil {
t.Fatalf("create link 1: %v", err)
}
// Rejeu même token, même ressource, même owner (nouvel operation_id) → succès.
result, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{link(repository.NewID())})
if err != nil || result.Applied != 1 || result.Failed != nil {
t.Errorf("rejeu lien identique: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
}
func TestCreateLinkTokenReuseConflict(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "linkconf-owner")
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileA := repository.NewID()
fileB := repository.NewID()
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileA, OpCreateResource, "file", map[string]any{"name": "a.txt"}),
syncOp(repository.NewID(), fileB, OpCreateResource, "file", map[string]any{"name": "b.txt"}),
}); err != nil {
t.Fatalf("create: %v", err)
}
token := repository.NewID()
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileA, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
}); err != nil {
t.Fatalf("create link: %v", err)
}
// Même token vers une AUTRE ressource du même owner → NAME_CONFLICT (#3).
result, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileB, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NAME_CONFLICT" {
t.Errorf("token réutilisé: attendu applied=0 NAME_CONFLICT, got %+v", result)
}
}
func TestCreateLinkTokenOwnerMismatch(t *testing.T) {
s := newServiceStore(t)
owner1 := mustCreateUser(t, s.Repository, "linkown-1")
owner2 := mustCreateUser(t, s.Repository, "linkown-2")
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileA := repository.NewID()
fileB := repository.NewID()
if _, err := s.ApplyBatch(owner1, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileA, OpCreateResource, "file", map[string]any{"name": "a.txt"}),
}); err != nil {
t.Fatalf("create A: %v", err)
}
if _, err := s.ApplyBatch(owner2, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileB, OpCreateResource, "file", map[string]any{"name": "b.txt"}),
}); err != nil {
t.Fatalf("create B: %v", err)
}
token := repository.NewID()
if _, err := s.ApplyBatch(owner1, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileA, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
}); err != nil {
t.Fatalf("create link: %v", err)
}
// Même token, autre owner → NAME_CONFLICT (#3).
result, err := s.ApplyBatch(owner2, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileB, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NAME_CONFLICT" {
t.Errorf("token d'autrui: attendu applied=0 NAME_CONFLICT, got %+v", result)
}
}
func TestUpdateMetadataAbsentHalts(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "ren-absent")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
// update_metadata sur ressource inexistante → NOT_FOUND halt (A8).
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
syncOp(repository.NewID(), repository.NewID(), OpUpdateMetadata, "file", map[string]any{"name": "ghost.txt"}),
})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Errorf("rename absent: attendu applied=0 NOT_FOUND, got %+v", result)
}
}
func TestMoveForeignHalts(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "movef-owner")
outsiderID := mustCreateUser(t, s.Repository, "movef-outsider")
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
targetID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}),
syncOp(repository.NewID(), targetID, OpCreateResource, "folder", map[string]any{"name": "t"}),
}); err != nil {
t.Fatalf("create: %v", err)
}
// Move d'une ressource d'autrui (jamais partagée) → NOT_FOUND halt.
result, err := s.ApplyBatch(outsiderID, shareTestDeviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}),
})
if err != nil {
t.Fatalf("ApplyBatch: %v", err)
}
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Errorf("move étranger: attendu applied=0 NOT_FOUND, got %+v", result)
}
}
func TestDeleteAbsentIsIdempotentNoop(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "delabsent-owner")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
// Delete d'une ressource sans ligne vivante → no-op idempotent (état
// terminal déjà atteint), pas de halt.
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
syncOp(repository.NewID(), repository.NewID(), OpDeleteResource, "file", map[string]any{}),
})
if err != nil || result.Applied != 1 || result.Failed != nil {
t.Errorf("delete absent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
}
-19
View File
@@ -1,19 +0,0 @@
package service
import (
"fmt"
"github.com/vaultdrop/backend/models"
)
func (s *Services) UploadDocument(file *string, destination *models.Document) error {
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, destination); !canEdit {
return fmt.Errorf("Can not edit")
}
models.NewDocument("test", models.FILE, 1)
return nil
}
+51
View File
@@ -0,0 +1,51 @@
# Déploiement perso — pull l'image depuis le registre Gitea (pas de build local).
#
# Usage sur le serveur :
# 1. cp .env.prod.example .env.prod && adapter (mots de passe forts, jamais commité)
# 2. echo "<PAT read:package>" | docker login gitea.thirdshop.fr -u <user> --password-stdin
# 3. docker compose -f docker-compose.prod.yml --env-file .env.prod pull
# 4. docker compose -f docker-compose.prod.yml --env-file .env.prod up -d
# 5. curl http://localhost:${PORT:-8080}/api/v1/health
#
# MAJ : répéter pull + up -d (ou tag précis via VERSION=x.y.z).
services:
postgres:
image: postgres:17-alpine
environment:
POSTGRES_DB: ${POSTGRES_DB:-kazier}
POSTGRES_USER: ${POSTGRES_USER:-kazier}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis (.env.prod)}
volumes:
- postgres-data:/var/lib/postgresql/data
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-kazier}"]
interval: 10s
timeout: 5s
retries: 5
backend:
# Image publiée par la release Gitea (tag vX.Y.Z + latest).
image: ${REGISTRY_IMAGE:-gitea.thirdshop.fr/thirdshop/kazier}:${VERSION:-latest}
ports:
- "${PORT:-8080}:8080"
environment:
PORT: 8080
DATABASE_URL: postgres://${POSTGRES_USER:-kazier}:${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis}@postgres:5432/${POSTGRES_DB:-kazier}?sslmode=disable
UPLOAD_DIR: /app/uploads
MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50}
OCR_LANG: ${OCR_LANG:-fra+eng}
AUTH_SECRET: ${AUTH_SECRET:?AUTH_SECRET requis (.env.prod)}
ADMIN_USERNAME: ${ADMIN_USERNAME:?ADMIN_USERNAME requis au premier démarrage}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:?ADMIN_PASSWORD requis au premier démarrage}
volumes:
- backend-uploads:/app/uploads
depends_on:
postgres:
condition: service_healthy
restart: unless-stopped
volumes:
postgres-data:
backend-uploads:
+28 -30
View File
@@ -1,47 +1,45 @@
services: services:
# paddleocr envisagé, non retenu — OCR via Tesseract (appel système), cf. docs/api-v1.md
# paddleocr:
# build:
# context: ./backend/ocr-server
# dockerfile: Dockerfile
# ports:
# - "9090:8080"
# environment:
# - OCR_LANG=fr
# restart: unless-stopped
postgres: postgres:
image: postgres:17-alpine image: postgres:17-alpine
ports: ports:
- "5432:5432" - "5432:5432"
environment: environment:
POSTGRES_DB: vaultdrop_dev POSTGRES_DB: ${POSTGRES_DB:-kazier_dev}
POSTGRES_USER: vaultdrop POSTGRES_USER: ${POSTGRES_USER:-kazier}
POSTGRES_PASSWORD: vaultdrop POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-kazier}
volumes: volumes:
- postgres-data:/var/lib/postgresql/data - postgres-data:/var/lib/postgresql/data
restart: unless-stopped restart: unless-stopped
healthcheck: healthcheck:
test: ["CMD-SHELL", "pg_isready -U vaultdrop"] test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-kazier}"]
interval: 10s interval: 10s
timeout: 5s timeout: 5s
retries: 5 retries: 5
# backend: backend:
# build: build:
# context: ./backend context: ./backend
# dockerfile: Dockerfile dockerfile: Dockerfile
# ports: args:
# - "8080:8080" VERSION: ${VERSION:-dev}
# environment: ports:
# - PORT=8080 - "${PORT:-8080}:8080"
# - DATABASE_URL=postgres://vaultdrop:vaultdrop@postgres:5432/vaultdrop_dev?sslmode=disable environment:
# volumes: PORT: 8080
# - ./backend/uploads:/app/uploads DATABASE_URL: postgres://${POSTGRES_USER:-kazier}:${POSTGRES_PASSWORD:-kazier}@postgres:5432/${POSTGRES_DB:-kazier_dev}?sslmode=disable
# depends_on: UPLOAD_DIR: /app/uploads
# postgres: MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50}
# condition: service_healthy OCR_LANG: ${OCR_LANG:-fra+eng}
# restart: unless-stopped AUTH_SECRET: ${AUTH_SECRET:?AUTH_SECRET requis (voir backend/.env.example)}
ADMIN_USERNAME: ${ADMIN_USERNAME:?ADMIN_USERNAME requis au premier démarrage}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:?ADMIN_PASSWORD requis au premier démarrage}
volumes:
- backend-uploads:/app/uploads
depends_on:
postgres:
condition: service_healthy
restart: unless-stopped
volumes: volumes:
postgres-data: postgres-data:
backend-uploads:
+15 -7
View File
@@ -1,6 +1,6 @@
# VaultDrop — Contrat API V1 (autoritatif) # Kazier — Contrat API V1 (autoritatif)
Status : **autoritatif**. Le client mobile est la source de vérité : `mobile/api/types.ts` + `mobile/api/client.ts` sont implémentés et testés ; le serveur Go doit les matcher exactement (méthode + path + enveloppe), il ne re-négocie pas. Document consolidé à partir de ces deux fichiers — toute divergence de ce doc doit être portée dans le client d'abord. Status : **autoritatif**. Le client mobile Kotlin est la source de vérité : `data/remote/ApiService.kt` + `data/remote/dto/Dtos.kt` (contrat Retrofit/Moshi) sont implémentés ; le serveur Go doit les matcher exactement (méthode + path + enveloppe), il ne re-négocie pas. Document consolidé depuis le client — toute divergence de ce doc doit être portée dans le client d'abord.
Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync), `AGENTS.md` (structure + commandes). Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync), `AGENTS.md` (structure + commandes).
@@ -8,7 +8,7 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
## 1. Base et transport ## 1. Base et transport
- Base URL serveur : schéma + host configurés côté client via `EXPO_PUBLIC_API_BASE_URL` (défaut `http://localhost:8080/api/v1`). - Base URL serveur : configurable à l'exécution dans les Réglages de l'appli (défaut `http://10.0.2.2:8080/api/v1`).
- JSON partout, sauf `POST /files/upload` (multipart). - JSON partout, sauf `POST /files/upload` (multipart).
- Enveloppe succès : `{ "data": T, "meta"?: { "page": int, "pageSize": int, "total": int } }` (`meta` présent sur les listes paginées). - Enveloppe succès : `{ "data": T, "meta"?: { "page": int, "pageSize": int, "total": int } }` (`meta` présent sur les listes paginées).
- Erreur : `{ "error": { "code": string, "message": string } }` + statut HTTP adéquat. - Erreur : `{ "error": { "code": string, "message": string } }` + statut HTTP adéquat.
@@ -37,16 +37,20 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
| PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` | `INVALID_PASSWORD` (403) | | PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` | `INVALID_PASSWORD` (403) |
| GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — | | GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — |
| GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` | | GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` |
| GET | `/files/:id/content` | — (binaire brut, hors enveloppe `{data}` ; `Range` supporté) | octets physiques (`Content-Type` du fichier, `Content-Disposition: inline`) — streaming lecture seule, jamais persisté côté client | `NOT_FOUND` (invisible OU metadata-only jamais uploadé — indistinguables) |
| DELETE | `/files/:id` | — | `{ "id": "…" }` | `NOT_FOUND` | | DELETE | `/files/:id` | — | `{ "id": "…" }` | `NOT_FOUND` |
| GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — | | GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — |
| GET | `/files/folders` | — | `FolderDto[]` (racines) | — | | GET | `/files/folders` | — | `FolderDto[]` (racines) | — |
| POST | `/files/upload` | multipart : `file` (uri/name/type), `folderId?` | `FileDto` | `FILE_TOO_LARGE` | | POST | `/files/upload` | multipart : `file` (uri/name/type), `folderId?` | `FileDto` | `FILE_TOO_LARGE` |
| POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — | | POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — |
| GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` | | GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` |
| GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` |
| GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, username, access, inherit, expiresAt (ms\|null), updatedAt (ms) }`) | `NOT_FOUND` (non-owner ou inconnue — pas d'énumération) |
| GET | `/files/:id/links` | — (owner uniquement) | `ShareLink[]` (même forme que `GET /shares/links/:token`) | `NOT_FOUND` (non-owner ou inconnue) |
| POST | `/sync/ops` | voir §6 | voir §6 | — | | POST | `/sync/ops` | voir §6 | voir §6 | — |
| GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — | | GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — |
> **Lecture partagée** : `GET /files`, `GET /files/:id`, `GET /files/search` et `GET /files/folders` couvrent les ressources **possédées ET partagées** (accès `viewer+`, §6.2). Le rename d'une ressource partagée passe par l'outbox `update_metadata` (nécessite `editor+`, §6.1). `DELETE /files/:id` reste owner-only. > **Lecture partagée** : `GET /files`, `GET /files/:id`, `GET /files/search`, `GET /files/:id/ocr` et `GET /files/folders` couvrent les ressources **possédées ET partagées** (accès `viewer+`, §6.2). Le rename d'une ressource partagée passe par l'outbox `update_metadata` (nécessite `editor+`, §6.1). `DELETE /files/:id` reste owner-only.
### DTOs (copie conforme de `mobile/api/types.ts`) ### DTOs (copie conforme de `mobile/api/types.ts`)
@@ -64,20 +68,24 @@ type FileDto = {
type FolderDto = { id: string; name: string; parentId?: string | null }; type FolderDto = { id: string; name: string; parentId?: string | null };
type OcrJobStatus = 'queued' | 'processing' | 'done' | 'failed'; type OcrJobStatus = 'queued' | 'processing' | 'done' | 'failed';
type OcrJob = { id: string; status: OcrJobStatus; text?: string | null; error?: string | null }; type OcrJob = { id: string; status: OcrJobStatus; text?: string | null; error?: string | null };
type FileOcr = { text: string; updatedAt?: string | null };
``` ```
## 4. Upload ## 4. Upload
- Multipart : champ `file` + `folderId?` optionnel. **Le client ne fixe jamais `Content-Type`** (le boundary doit être généré par la plateforme). - Multipart : champ `file` + `folderId?` optionnel + `resourceId?` optionnel. **Le client ne fixe jamais `Content-Type`** (le boundary doit être généré par la plateforme).
- `resourceId` optionnel : cible un **fichier déjà connu du user** (créé metadata-only via l'outbox `create_resource`, ou précédemment uploadé) pour lui **attacher ses octets physiques** — cas d'usage : le client local-first doit fournir le bytes d'un fichier SAF pour l'OCR serveur (`POST /ocr/jobs`). Le `resourceId` fourni doit exister et appartenir au user (sinon `NOT_FOUND`, même réponses/format que `GET /files/:id`) ; la ligne n'est **jamais re-créée ni renommée ni déplacée**, seule la métadonnée physique (`size`/`mimeType`/extension) est rafraîchie et `FileDto` renvoyé. `resourceId` absent → comportement historique (nouvelle ressource).
- Limite : `MAX_FILE_SIZE_MB` (défaut 50). Dépassement → 413 `{ "error": { "code": "FILE_TOO_LARGE", … } }`. - Limite : `MAX_FILE_SIZE_MB` (défaut 50). Dépassement → 413 `{ "error": { "code": "FILE_TOO_LARGE", … } }`.
- Le fichier physique est stocké sous `UPLOAD_DIR/<user_id>/<resource_id>.<ext>` ; la métadonnée est persistée en base et renvoyée en `FileDto`. Si la persistance de la métadonnée échoue (ex. `NAME_CONFLICT`), le fichier physique est supprimé. - Le fichier physique est stocké sous `UPLOAD_DIR/<user_id>/<resource_id>.<ext>` ; la métadonnée est persistée en base et renvoyée en `FileDto`. Si la persistance de la métadonnée échoue (ex. `NAME_CONFLICT`), le fichier physique est supprimé.
## 5. OCR ## 5. OCR
- `POST /ocr/jobs { fileId }` → `OcrJob` immédiat (`status: queued`), traitement **asynchrone** (goroutine par job côté serveur, V1). - `POST /ocr/jobs { fileId }` → `OcrJob` immédiat (`status: queued`), traitement **asynchrone** par une **file serveur bornée** (`ocr_jobs` + worker `Ocr.Run`, `OCR_WORKERS` défaut 2) — le handler n'enfile **jamais** de traitement, Tesseract tourne hors request handler (FIFO, récupération des `processing` orphelins au boot).
- `GET /ocr/jobs/:id` → statut. Le mobile **poll toutes les 3s** jusqu'à `done`/`failed` (`hooks/useUpload.ts`). Cycle : `queued → processing → done | failed` ; `done` renvoie `text`, `failed` renvoie `error`. - `GET /ocr/jobs/:id` → statut. Le mobile **poll toutes les 3s** jusqu'à `done`/`failed` (`hooks/useUpload.ts`). Cycle : `queued → processing → done | failed` ; `done` renvoie `text`, `failed` renvoie `error`.
- Moteur : **Tesseract en appel système** (`ocr/tesseract.go`), langue `OCR_LANG` (défaut `fra+eng`). Les images sont passées directement à `tesseract` ; les **PDF** subissent une extraction du calque texte (`ledongthuc/pdf`, déjà en go.mod) — un PDF scanné produit un texte vide plutôt qu'un rendu/OCR (hors scope V1). - Moteur : **Tesseract en appel système** (`ocr/tesseract.go`), langue `OCR_LANG` (défaut `fra+eng`). Les images sont passées directement à `tesseract` ; les **PDF** subissent une extraction du calque texte (`ledongthuc/pdf`, déjà en go.mod) — un PDF scanné produit un texte vide plutôt qu'un rendu/OCR (hors scope V1).
- `fileId` inconnu/pas du user → `NOT_FOUND`. Fichier physique introuvable (ex. suppression manuelle sous `UPLOAD_DIR`) → job `failed` `"file not readable"`. Le job est créé par le device courant (`ocr_jobs.device_id`) mais la validation de la ressource est scopée par le **user**. - `fileId` inconnu/pas du user → `NOT_FOUND`. Fichier physique introuvable (ex. suppression manuelle sous `UPLOAD_DIR`) → job `failed` `"file not readable"`. Le job est créé par le device courant (`ocr_jobs.device_id`) mais la validation de la ressource est scopée par le **user**.
- **Le texte atterrit sur la ressource** : à la complétion (`done` avec texte non vide), le worker écrit l'extrait trimé dans `resources.ocr_text` (et **bump `updated_at`**, d'où une injection dans le delta outbox/snapshot). `ocr_jobs.text` reste l'historique du job.
- **`GET /files/:id/ocr`** → `FileOcr { text, updatedAt }` : l'extrait server-side du fichier, lisible par le **possédant ET les grantees** (`viewer+`, même portée que `GET /files/:id` ; `text` `""` si pas encore extrait). Un **second device** rapatrie ainsi le texte d'un OCR fait par un autre device (ou par la ressource partagée) **sans re-téléverser les octets ni re-soumettre de job** — le client Kotlin le fait en tête de `OcrRepository.syncFromServer`/`processAuto` et du viewer (`OcrViewModel`).
## 6. Contrat de sync (outbox + snapshot) ## 6. Contrat de sync (outbox + snapshot)
@@ -114,7 +122,7 @@ type OcrJob = { id: string; status: OcrJobStatus; text?: string | null; error?:
- `revoke_link` : `payload = { "token": "…32-hex" }`. **Idempotent**. - `revoke_link` : `payload = { "token": "…32-hex" }`. **Idempotent**.
- Validation (deuxième champ `operation_id`, hex32 pour `resource_id` **et** `operation_id`, enum `operation`) → échec `INVALID_REQUEST` avec arrêt du batch. - Validation (deuxième champ `operation_id`, hex32 pour `resource_id` **et** `operation_id`, enum `operation`) → échec `INVALID_REQUEST` avec arrêt du batch.
- Nom déjà pris (même parent, ou à la racine) → échec `NAME_CONFLICT`.** - Nom déjà pris (même parent, ou à la racine) → échec `NAME_CONFLICT`.**
- **Lien public** : `GET /shares/links/:token` est **sans authentification** (résolution publique d'un lien) et renvoie `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }`. `NOT_FOUND` si le lien est inconnu, révoqué ou expiré. - **Lien public** : `GET /shares/links/:token` est **sans authentification** (résolution publique d'un lien) et renvoie `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }`. `NOT_FOUND` si le lien est inconnu, révoqué ou expiré. Le client partage les liens sous forme de deep-link `kazier://share/<token>` (custom scheme, pas d'App Links https) : indépendant du domaine du serveur, donc compatible self-hosting (chaque instance a son propre host).
### 6.2 Snapshot — `GET /sync/permissions?after=<cached_at_ms>` ### 6.2 Snapshot — `GET /sync/permissions?after=<cached_at_ms>`
+93 -2
View File
@@ -21,8 +21,99 @@ set -euo pipefail
./gradlew :app:assembleDebug -q ./gradlew :app:assembleDebug -q
APK="app/build/outputs/apk/debug/app-debug.apk" APK="app/build/outputs/apk/debug/app-debug.apk"
if [ "${usage_target?}" = "emulator" ]; then if [ "${usage_target?}" = "emulator" ]; then
adb -e install -r "$APK" ADB_FLAGS=(-e)
else else
adb -d install -r "$APK" ADB_FLAGS=(-d)
fi
# adb natif s'il fonctionne (PATH + binaire exécutable sur cet OS)...
if command -v adb >/dev/null 2>&1 && adb version >/dev/null 2>&1; then
adb "${ADB_FLAGS[@]}" install -r "$APK"
# ...sinon repli NixOS : l'adb du SDK est un binaire FHS dynamiquement
# lié, on l'exécute via steam-run (cf. local.properties pour sdk.dir).
elif command -v steam-run >/dev/null 2>&1; then
SDK_DIR="${ANDROID_SDK_ROOT:-${ANDROID_HOME:-}}"
if [ -z "$SDK_DIR" ] && [ -f local.properties ]; then
SDK_DIR="$(sed -n 's/^sdk\.dir=//p' local.properties | head -n 1)"
fi
if [ -z "$SDK_DIR" ] && [ -d "$HOME/Android/Sdk" ]; then
SDK_DIR="$HOME/Android/Sdk"
fi
if [ -z "$SDK_DIR" ] || [ ! -x "$SDK_DIR/platform-tools/adb" ]; then
echo "adb introuvable : définissez ANDROID_HOME ou sdk.dir dans local.properties." >&2
exit 1
fi
export LD_LIBRARY_PATH="${LD_LIBRARY_PATH:-}:$HOME/.nix-profile/lib:/run/opengl-driver/lib"
steam-run "$SDK_DIR/platform-tools/adb" "${ADB_FLAGS[@]}" install -r "$APK"
else
echo "adb ne fonctionne pas sur cet OS et steam-run est absent (NixOS)." >&2
exit 1
fi fi
''' '''
[tasks.test]
description = "Run all tests (Go + Kotlin)"
run = '''
set -euo pipefail
cd backend && go test ./...
cd ../mobile-kotlin && ./gradlew :app:testDebugUnitTest -q
'''
[tasks.build]
description = "Build all artifacts (Go binary + Android APK)"
run = '''
set -euo pipefail
VERSION=$(cat VERSION)
mkdir -p backend/bin
cd backend && go build -ldflags "-X main.version=$VERSION" -o bin/kazier-server cmd/server/main.go
cd ../mobile-kotlin && ./gradlew :app:assembleDebug -q
'''
[tasks.lint]
description = "Lint all code (staticcheck + Android Lint)"
run = '''
set -euo pipefail
cd backend && staticcheck ./...
cd ../mobile-kotlin && ./gradlew :app:lint -q
'''
[tasks."build:release"]
description = "Build signed release APK (assembleRelease)"
dir = "mobile-kotlin"
run = '''
#!/usr/bin/env bash
set -euo pipefail
if [ ! -f app/signing.properties ] && [ -z "${SIGNING_STORE_FILE:-}" ]; then
echo "signing.properties absent — copiez app/signing.properties.example et"
echo "préparez un keystore, ou fournissez SIGNING_STORE_FILE (CI)." >&2
exit 1
fi
./gradlew :app:assembleRelease -q
echo "APK : app/build/outputs/apk/release/app-release.apk"
'''
[tasks."docker:build"]
description = "Build the backend Docker image (tagged with VERSION)"
run = '''
set -euo pipefail
VERSION=$(cat VERSION)
docker build \\
--build-arg VERSION="$VERSION" \\
--build-arg BUILD_DATE="$(date -u +%Y-%m-%dT%H:%M:%SZ)" \\
-t kazier-server:"$VERSION" \\
./backend
echo "Image : kazier-server:$VERSION"
'''
[tasks.release]
description = "Local release checklist: test, build artifacts, tag, push"
run = '''
set -euo pipefail
VERSION=$(cat VERSION)
echo ">>> Version : $VERSION (tag cible v$VERSION)"
mise run test
mise run build
mise run docker:build
echo
echo "Prêt à tagger ? La CI GitLab construira la release finale à partir du tag."
echo " git tag v$VERSION && git push origin v$VERSION"
'''
+37 -4
View File
@@ -8,19 +8,34 @@ plugins {
alias(libs.plugins.hilt) alias(libs.plugins.hilt)
} }
// Source unique de vérité : VERSION à la racine du dépôt (ex. 0.1.0).
val kazierVersion: String = rootProject.file("../VERSION").readText().trim()
val kazierVersionCode: Int = run {
val parts = kazierVersion.split('.').map { it.toInt() }
check(parts.size == 3) { "VERSION doit être major.minor.patch, reçu: $kazierVersion" }
parts[0] * 1_000_000 + parts[1] * 1_000 + parts[2]
}
// Signature release : signing.properties (gitignoré) en local, variables
// d'env (SIGNING_*) en CI. Jamais de keystore commité.
val signingProps = Properties().apply {
val f = file("signing.properties")
if (f.exists()) f.inputStream().use { load(it) }
}
android { android {
namespace = "com.vaultdrop.mobile" namespace = "com.kazier.mobile"
compileSdk = 35 compileSdk = 35
defaultConfig { defaultConfig {
applicationId = "com.vaultdrop.mobile" applicationId = "com.kazier.mobile"
minSdk = 26 minSdk = 26
// targetSdk 35 exige des .so alignés en 16K ; les libs précompilées // targetSdk 35 exige des .so alignés en 16K ; les libs précompilées
// OpenCV/CameraX sont en 4K (warning de compatibilité sur devices // OpenCV/CameraX sont en 4K (warning de compatibilité sur devices
// 16K-pages). On reste en 34 tant qu'elles ne sont pas mises à jour. // 16K-pages). On reste en 34 tant qu'elles ne sont pas mises à jour.
targetSdk = 34 targetSdk = 34
versionCode = 1 versionCode = kazierVersionCode
versionName = "0.1.0" versionName = kazierVersion
// OpenCV natif : on conserve uniquement les ABIs ciblés // OpenCV natif : on conserve uniquement les ABIs ciblés
// (arm64 = devices, x86_64 = émulateur) pour garder l'APK raisonnable. // (arm64 = devices, x86_64 = émulateur) pour garder l'APK raisonnable.
@@ -29,6 +44,18 @@ android {
} }
} }
signingConfigs {
create("release") {
val storePath = signingProps.getProperty("storeFile") ?: System.getenv("SIGNING_STORE_FILE")
if (storePath != null) {
storeFile = file(storePath)
storePassword = signingProps.getProperty("storePassword") ?: System.getenv("SIGNING_STORE_PASSWORD")
keyAlias = signingProps.getProperty("keyAlias") ?: System.getenv("SIGNING_KEY_ALIAS")
keyPassword = signingProps.getProperty("keyPassword") ?: System.getenv("SIGNING_KEY_PASSWORD")
}
}
}
buildTypes { buildTypes {
release { release {
isMinifyEnabled = false isMinifyEnabled = false
@@ -36,6 +63,7 @@ android {
getDefaultProguardFile("proguard-android-optimize.txt"), getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro", "proguard-rules.pro",
) )
signingConfig = signingConfigs.getByName("release")
} }
} }
compileOptions { compileOptions {
@@ -56,6 +84,11 @@ android {
} }
} }
// m19 : export du schéma Room (`app/schemas/`) pour détecter les dérives en CI.
ksp {
arg("room.schemaLocation", "$projectDir/schemas")
}
dependencies { dependencies {
implementation(libs.androidx.core.ktx) implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx) implementation(libs.androidx.lifecycle.runtime.ktx)
@@ -0,0 +1,730 @@
{
"formatVersion": 1,
"database": {
"version": 16,
"identityHash": "ec10fdb23d5da3a76a73222e9c404561",
"entities": [
{
"tableName": "folders",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `exists` INTEGER, `parent_resource_id` TEXT, `owner_id` TEXT, `sync_status` TEXT NOT NULL, `created_in_app` INTEGER NOT NULL DEFAULT 0, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "uri",
"columnName": "uri",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "exists",
"columnName": "exists",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "parentResourceId",
"columnName": "parent_resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "syncStatus",
"columnName": "sync_status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdInApp",
"columnName": "created_in_app",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "addedAt",
"columnName": "added_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_folders_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_folders_uri",
"unique": true,
"columnNames": [
"uri"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_uri` ON `${TABLE_NAME}` (`uri`)"
},
{
"name": "index_folders_parent_resource_id",
"unique": false,
"columnNames": [
"parent_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_folders_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "user_preferences",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`key` TEXT NOT NULL, `value` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`key`))",
"fields": [
{
"fieldPath": "key",
"columnName": "key",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "value",
"columnName": "value",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"key"
]
},
"indices": [],
"foreignKeys": []
},
{
"tableName": "files",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `folder_resource_id` TEXT NOT NULL, `extension` TEXT, `size` INTEGER NOT NULL, `mime_type` TEXT, `exists` INTEGER, `last_modified` INTEGER, `owner_id` TEXT, `category` TEXT, `sync_status` TEXT NOT NULL, `content` TEXT, `processed` INTEGER NOT NULL, `ocr_text` TEXT, `ocr_attempts` INTEGER NOT NULL, `ocr_queued_at` INTEGER, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "uri",
"columnName": "uri",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "folderResourceId",
"columnName": "folder_resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "extension",
"columnName": "extension",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "size",
"columnName": "size",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "mimeType",
"columnName": "mime_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "exists",
"columnName": "exists",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "lastModified",
"columnName": "last_modified",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "category",
"columnName": "category",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "syncStatus",
"columnName": "sync_status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "content",
"columnName": "content",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "processed",
"columnName": "processed",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ocrText",
"columnName": "ocr_text",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "ocrAttempts",
"columnName": "ocr_attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ocrQueuedAt",
"columnName": "ocr_queued_at",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "addedAt",
"columnName": "added_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_files_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_files_uri",
"unique": true,
"columnNames": [
"uri"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_uri` ON `${TABLE_NAME}` (`uri`)"
},
{
"name": "index_files_folder_resource_id",
"unique": false,
"columnNames": [
"folder_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_folder_resource_id` ON `${TABLE_NAME}` (`folder_resource_id`)"
},
{
"name": "index_files_category",
"unique": false,
"columnNames": [
"category"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_category` ON `${TABLE_NAME}` (`category`)"
},
{
"name": "index_files_exists_processed_sync_status",
"unique": false,
"columnNames": [
"exists",
"processed",
"sync_status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` ON `${TABLE_NAME}` (`exists`, `processed`, `sync_status`)"
}
],
"foreignKeys": []
},
{
"tableName": "pending_operations",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_id` TEXT, `operation_id` TEXT NOT NULL, `ref_type` TEXT, `ref_id` INTEGER, `resource_id` TEXT, `resource_type` TEXT, `operation` TEXT NOT NULL, `payload` TEXT NOT NULL, `parent_resource_id` TEXT, `status` TEXT NOT NULL, `attempts` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "deviceId",
"columnName": "device_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "operationId",
"columnName": "operation_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "refType",
"columnName": "ref_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "refId",
"columnName": "ref_id",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "resourceType",
"columnName": "resource_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "operation",
"columnName": "operation",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "payload",
"columnName": "payload",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "parentResourceId",
"columnName": "parent_resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "attempts",
"columnName": "attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_pending_operations_device_id_operation_id",
"unique": true,
"columnNames": [
"device_id",
"operation_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_pending_operations_device_id_operation_id` ON `${TABLE_NAME}` (`device_id`, `operation_id`)"
},
{
"name": "index_pending_operations_status",
"unique": false,
"columnNames": [
"status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_status` ON `${TABLE_NAME}` (`status`)"
},
{
"name": "index_pending_operations_resource_id",
"unique": false,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_pending_operations_resource_id_operation_status",
"unique": false,
"columnNames": [
"resource_id",
"operation",
"status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` ON `${TABLE_NAME}` (`resource_id`, `operation`, `status`)"
},
{
"name": "index_pending_operations_parent_resource_id",
"unique": false,
"columnNames": [
"parent_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "scan_sessions",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `root_folder_id` TEXT, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "rootFolderId",
"columnName": "root_folder_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_scan_sessions_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_sessions_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "scan_pages",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `session_id` INTEGER NOT NULL, `temp_uri` TEXT NOT NULL, `corners_json` TEXT NOT NULL, `width` INTEGER NOT NULL, `height` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, FOREIGN KEY(`session_id`) REFERENCES `scan_sessions`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "sessionId",
"columnName": "session_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "tempUri",
"columnName": "temp_uri",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "cornersJson",
"columnName": "corners_json",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "width",
"columnName": "width",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "height",
"columnName": "height",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "sortOrder",
"columnName": "sort_order",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_scan_pages_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_pages_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_scan_pages_session_id",
"unique": false,
"columnNames": [
"session_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_session_id` ON `${TABLE_NAME}` (`session_id`)"
},
{
"name": "index_scan_pages_sort_order",
"unique": false,
"columnNames": [
"sort_order"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_sort_order` ON `${TABLE_NAME}` (`sort_order`)"
}
],
"foreignKeys": [
{
"table": "scan_sessions",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"session_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "resource_permissions",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`resource_id` TEXT NOT NULL, `resource_type` TEXT NOT NULL, `effective_access` TEXT NOT NULL, `owner_id` TEXT, `shared_by_id` TEXT, `expires_at` INTEGER, `cached_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`resource_id`))",
"fields": [
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "resourceType",
"columnName": "resource_type",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "effectiveAccess",
"columnName": "effective_access",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "sharedById",
"columnName": "shared_by_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "expiresAt",
"columnName": "expires_at",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "cachedAt",
"columnName": "cached_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"resource_id"
]
},
"indices": [
{
"name": "index_resource_permissions_expires_at",
"unique": false,
"columnNames": [
"expires_at"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` ON `${TABLE_NAME}` (`expires_at`)"
}
],
"foreignKeys": []
}
],
"views": [],
"setupQueries": [
"CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
"INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'ec10fdb23d5da3a76a73222e9c404561')"
]
}
}
@@ -0,0 +1,16 @@
# Signature release Android — copier vers signing.properties (jamais commité)
# Alternative CI : mêmes valeurs via les variables d'environnement SIGNING_*.
#
# 1. Générer un keystore (ne jamais le committer, garder en lieu sûr) :
# keytool -genkey -v -keystore release.keystore -alias kazier \
# -keyalg RSA -keysize 2048 -validity 10000
# Note : un keystore existant garde SON alias d'origine (ex. kazier) —
# reporter alors la même valeur dans keyAlias ci-dessous.
# 2. Renseigner les valeurs ci-dessous.
#
# storeFile est relatif au répertoire du module app/ (mobile-kotlin/app).
storeFile=release.keystore
storePassword=CHANGE_ME
keyAlias=kazier
keyPassword=CHANGE_ME
+14 -4
View File
@@ -10,17 +10,17 @@
android:required="false" /> android:required="false" />
<application <application
android:name=".VaultDropApplication" android:name=".KazierApplication"
android:allowBackup="true" android:allowBackup="true"
android:icon="@mipmap/ic_launcher" android:icon="@mipmap/ic_launcher"
android:label="@string/app_name" android:label="@string/app_name"
android:supportsRtl="true" android:supportsRtl="true"
android:usesCleartextTraffic="true" android:usesCleartextTraffic="true"
android:theme="@style/Theme.VaultDrop"> android:theme="@style/Theme.Kazier">
<!-- HiltWorkerFactory : désactive l'initialisation WorkManager par <!-- HiltWorkerFactory : désactive l'initialisation WorkManager par
défaut (androidx.startup) pour que Configuration.Provider défaut (androidx.startup) pour que Configuration.Provider
(VaultDropApplication) soit honoré — sinon le @HiltWorker ne peut (KazierApplication) soit honoré — sinon le @HiltWorker ne peut
pas être instancié (NoSuchMethodException). --> pas être instancié (NoSuchMethodException). -->
<provider <provider
android:name="androidx.startup.InitializationProvider" android:name="androidx.startup.InitializationProvider"
@@ -36,11 +36,21 @@
<activity <activity
android:name=".MainActivity" android:name=".MainActivity"
android:exported="true" android:exported="true"
android:theme="@style/Theme.VaultDrop"> android:theme="@style/Theme.Kazier">
<intent-filter> <intent-filter>
<action android:name="android.intent.action.MAIN" /> <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" /> <category android:name="android.intent.category.LAUNCHER" />
</intent-filter> </intent-filter>
<!-- Liens de partage `kazier://share/<token>` (32-hex) : ouverture
dans l'écran de résolution (route publique, sans auth). -->
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data
android:scheme="kazier"
android:host="share" />
</intent-filter>
</activity> </activity>
</application> </application>
@@ -1,4 +1,4 @@
package com.vaultdrop.mobile package com.kazier.mobile
import android.app.Application import android.app.Application
import androidx.hilt.work.HiltWorkerFactory import androidx.hilt.work.HiltWorkerFactory
@@ -8,7 +8,7 @@ import timber.log.Timber
import javax.inject.Inject import javax.inject.Inject
@HiltAndroidApp @HiltAndroidApp
class VaultDropApplication : Application(), Configuration.Provider { class KazierApplication : Application(), Configuration.Provider {
@Inject @Inject
lateinit var workerFactory: HiltWorkerFactory lateinit var workerFactory: HiltWorkerFactory
@@ -1,4 +1,4 @@
package com.vaultdrop.mobile package com.kazier.mobile
import android.os.Bundle import android.os.Bundle
import androidx.activity.ComponentActivity import androidx.activity.ComponentActivity
@@ -7,9 +7,9 @@ import androidx.activity.enableEdgeToEdge
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.lifecycleScope import androidx.lifecycle.lifecycleScope
import com.vaultdrop.mobile.domain.ThemePreferenceStore import com.kazier.mobile.domain.ThemePreferenceStore
import com.vaultdrop.mobile.ui.navigation.VaultDropApp import com.kazier.mobile.ui.navigation.KazierApp
import com.vaultdrop.mobile.ui.theme.VaultDropTheme import com.kazier.mobile.ui.theme.KazierTheme
import dagger.hilt.android.AndroidEntryPoint import dagger.hilt.android.AndroidEntryPoint
import javax.inject.Inject import javax.inject.Inject
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
@@ -24,12 +24,15 @@ class MainActivity : ComponentActivity() {
super.onCreate(savedInstanceState) super.onCreate(savedInstanceState)
enableEdgeToEdge() enableEdgeToEdge()
lifecycleScope.launch { themePreferenceStore.load() } // m37 : le contenu n'est posé qu'une fois le thème persisté chargé —
// avant, le défaut SYSTEM flashait aux premières frames.
setContent { lifecycleScope.launch {
val theme by themePreferenceStore.theme.collectAsStateWithLifecycle() themePreferenceStore.load()
VaultDropTheme(theme = theme) { setContent {
VaultDropApp() val theme by themePreferenceStore.theme.collectAsStateWithLifecycle()
KazierTheme(theme = theme) {
KazierApp()
}
} }
} }
} }
@@ -0,0 +1,90 @@
package com.kazier.mobile.auth
import android.content.Context
import android.content.SharedPreferences
import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKeys
import com.squareup.moshi.JsonAdapter
import com.squareup.moshi.Moshi
import com.kazier.mobile.data.remote.dto.UserDto
import dagger.hilt.android.qualifiers.ApplicationContext
import javax.inject.Inject
import javax.inject.Singleton
/**
* Persistance chiffrée du token paseto et du profil compte (Keystore + AES).
* Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est
* JAMAIS écrit en clair dans SQLite.
*
* L'init Keystore/`EncryptedSharedPreferences` est paresseuse (m28) : aucun
* I/O au construct Hilt — le premier accès a lieu sur le thread de l'appelant
* ([SessionManager] bascule sur `Dispatchers.IO`).
*/
@Singleton
class SecureTokenStore @Inject constructor(
@ApplicationContext private val context: Context,
moshi: Moshi,
) : TokenStore {
private val userAdapter: JsonAdapter<UserDto> = moshi.adapter(UserDto::class.java)
private val prefs: SharedPreferences by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
EncryptedSharedPreferences.create(
FILE_NAME,
masterKeyAlias,
context,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
)
}
override fun getToken(): String? = prefs.getString(KEY_TOKEN, null)
override fun getUser(): UserDto? {
val raw = prefs.getString(KEY_ACCOUNT, null) ?: return null
return runCatching { userAdapter.fromJson(raw) }
.getOrNull()
?.takeIf { it.id.isNotEmpty() && it.username.isNotEmpty() }
}
override fun getExpiresAt(): Long? =
prefs.getLong(KEY_EXPIRES_AT, -1L).takeIf { it >= 0L }
override fun getCredentials(): Credentials? {
val username = prefs.getString(KEY_USERNAME, null)?.takeIf { it.isNotBlank() } ?: return null
val password = prefs.getString(KEY_PASSWORD, null)?.takeIf { it.isNotEmpty() } ?: return null
return Credentials(username, password)
}
override fun saveCredentials(username: String, password: String) {
prefs.edit().putString(KEY_USERNAME, username).putString(KEY_PASSWORD, password).apply()
}
override fun clearCredentials() {
prefs.edit().remove(KEY_USERNAME).remove(KEY_PASSWORD).apply()
}
override fun save(token: String, user: UserDto, expiresAt: Long?) {
prefs.edit()
.putString(KEY_TOKEN, token)
.putString(KEY_ACCOUNT, userAdapter.toJson(user))
.apply {
if (expiresAt != null) putLong(KEY_EXPIRES_AT, expiresAt) else remove(KEY_EXPIRES_AT)
}
.apply()
}
override fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).remove(KEY_EXPIRES_AT).apply()
}
companion object {
private const val FILE_NAME = "kazier_secure"
private const val KEY_TOKEN = "kazier.auth_token"
private const val KEY_ACCOUNT = "kazier.account"
private const val KEY_EXPIRES_AT = "kazier.expires_at"
private const val KEY_USERNAME = "kazier.auth_username"
private const val KEY_PASSWORD = "kazier.auth_password"
}
}
@@ -0,0 +1,213 @@
package com.kazier.mobile.auth
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.dto.UserDto
import com.kazier.mobile.data.repository.AuthRepository
import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.LocalModeStore
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import timber.log.Timber
/** Événements de session vers l'UI (re-login silencieux, lot 3). */
sealed interface AuthEvent {
/** Le token a été renouvelé sans action utilisateur — rester connecté. */
data class Reauthenticated(val user: UserDto) : AuthEvent
/** Plus de session récupérable — afficher le login (pré-rempli si possible). */
data class SessionExpired(val username: String?) : AuthEvent
}
/**
* Orchestration de la session (restauration/sauvegarde/purge) : relie le store
* sécurisé, le miroir `active_user_id` et le token en mémoire lu par
* `AuthInterceptor`. Le drapeau « mode local » est persisté à part
* ([LocalModeStore]) pour survivre aux redémarrages.
*
* Le callback 401 est possédé ici (singleton, M25) — jamais par un ViewModel :
* après `onCleared`, un token expiré/révoqué continue d'être traité (le worker
* cesse alors de rejouer l'outbox sous un token mort).
*
* Re-login silencieux (lot 3) : les identifiants saisis au login sont
* persistés chiffrés ; sur 401 (ou token expiré détecté en proactif), une
* seule tentative de `POST /auth/login` est jouée (single-flight). Succès →
* [AuthEvent.Reauthenticated] (file conservée si même compte) ; identifiants
* rejetés → purge complète + [AuthEvent.SessionExpired]. La requête en vol
* ayant subi le 401 n'est PAS rejouée — l'appelant la relance (pull, retry).
*/
@Singleton
class SessionManager @Inject constructor(
private val tokenStore: TokenStore,
private val activeUserStore: ActiveUserStore,
private val tokenProvider: TokenProvider,
private val localModeStore: LocalModeStore,
private val pendingOperationDao: PendingOperationDao,
private val apiClient: ApiClient,
private val authRepository: AuthRepository,
) {
private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
/** Single-flight du re-login : N 401 concurrents → 1 seul `POST /auth/login`. */
private val reloginMutex = Mutex()
private val _events = MutableSharedFlow<AuthEvent>(extraBufferCapacity = 4)
val events: SharedFlow<AuthEvent> = _events.asSharedFlow()
init {
// 401 sur un endpoint protégé (token expiré/révoqué, compte supprimé)
// → re-login silencieux puis purge si irrécupérable. Le 401 du login
// et des routes publiques est exonéré côté ApiClient
// (skipUnauthorizedHandling).
apiClient.onUnauthorized = { handleUnauthorized() }
}
/** Restaure la session persistée (si présente), sinon null. */
suspend fun restore(): AuthSession? = withContext(Dispatchers.IO) {
val token = tokenStore.getToken() ?: return@withContext null
val user = tokenStore.getUser() ?: return@withContext null
tokenProvider.current = token
AuthSession(token = token, user = user, expiresAt = tokenStore.getExpiresAt())
}
suspend fun save(
token: String,
user: UserDto,
expiresAt: Long? = null,
username: String? = null,
password: String? = null,
) = withContext(Dispatchers.IO) {
val previousUserId = activeUserStore.get()
tokenStore.save(token, user, expiresAt)
if (username != null && password != null) {
tokenStore.saveCredentials(username, password)
}
activeUserStore.set(user.id)
localModeStore.clear()
tokenProvider.current = token
// Changement de compte sans sign-out explicite (login de B par
// dessus la session de A) : même purge que `clear()` — la file de
// A ne doit pas partir sous le token de B. Premier login
// (`previousUserId == null`, éventuel travail du mode local) et
// re-login du même compte : file conservée.
if (previousUserId != null && previousUserId != user.id) {
pendingOperationDao.deleteUnpushed()
}
}
suspend fun clear() = withContext(Dispatchers.IO) {
tokenStore.clear()
tokenStore.clearCredentials()
activeUserStore.clear()
tokenProvider.current = null
// Sign-out explicite : la file non poussée est abandonnée (C5, voir
// `deleteUnpushed`). Les ops `synced` survivent comme tombstones.
pendingOperationDao.deleteUnpushed()
}
/**
* 401 sur endpoint protégé (appelée depuis le thread OkHttp via
* `ApiClient`) : le token en mémoire tombe synchronement pour ne plus
* émettre de requêtes authentifiées, puis le re-login silencieux est tenté
* en IO (single-flight).
*/
fun handleUnauthorized() {
tokenProvider.current = null
scope.launch {
reloginMutex.withLock { silentReloginLocked() }
}
}
/**
* Re-login proactif (démarrage, retour foreground) : si le token en
* mémoire est absent ou expiré et que des identifiants sont sauvés, tente
* un renouvellement. Vrai si un token frais est disponible au retour.
*/
suspend fun trySilentRelogin(nowMs: Long = System.currentTimeMillis()): Boolean =
withContext(Dispatchers.IO) {
if (tokenProvider.current != null && !isTokenExpired(nowMs)) return@withContext true
reloginMutex.withLock { silentReloginLocked() }
}
/**
* Corps du re-login, sous [reloginMutex]. Vrai si la session est (à
* nouveau) valide. Émet [AuthEvent.Reauthenticated] en cas de succès et
* [AuthEvent.SessionExpired] quand rien n'est récupérable.
*/
private suspend fun silentReloginLocked(): Boolean {
// Re-vérification sous mutex : un re-login concurrent vient peut-être
// de rafraîchir le token pendant l'attente du verrou (N 401 → 1 login).
if (tokenProvider.current != null && !isTokenExpired()) return true
val creds = runCatching { tokenStore.getCredentials() }.getOrNull()
if (creds == null) {
purgeToExpired(username = null)
return false
}
return try {
val response = authRepository.login(creds.username, creds.password)
save(response.token, response.user, response.expiresAt)
Timber.d("auth: re-login silencieux OK pour %s", creds.username)
_events.tryEmit(AuthEvent.Reauthenticated(response.user))
true
} catch (e: Exception) {
if (e is ApiException && e.code == "UNAUTHORIZED") {
// Identifiants rejetés (mot de passe changé ailleurs, compte
// supprimé) : ne plus jamais les rejouer.
Timber.w("auth: re-login rejeté, purge des identifiants")
runCatching { tokenStore.clearCredentials() }
purgeToExpired(username = creds.username)
} else {
// Transitoire (réseau/5xx) : token mort, identifiants conservés
// pour une tentative ultérieure (prochain démarrage/login).
Timber.w(e, "auth: re-login transitoire, session expirée")
purgeToExpired(username = creds.username)
}
false
}
}
/** Purge token + compte actif (file intacte, cf. C5) + événement UI. */
private suspend fun purgeToExpired(username: String?) {
val knownUsername = username ?: runCatching { tokenStore.getUser()?.username }.getOrNull()
tokenProvider.current = null
runCatching { tokenStore.clear() }
runCatching { activeUserStore.clear() }
_events.tryEmit(AuthEvent.SessionExpired(knownUsername))
}
/**
* Pré-relogin : vrai si l'`expires_at` persistée du login est atteinte
* (marge anti-course d'1 min par défaut). L'appelant peut alors reloginer
* avant de subir le 401 brutal (tokens 7 j, m27).
*/
suspend fun isTokenExpired(nowMs: Long = System.currentTimeMillis(), marginMs: Long = 60_000L): Boolean =
withContext(Dispatchers.IO) {
val expiresAt = tokenStore.getExpiresAt() ?: return@withContext false
nowMs + marginMs >= expiresAt
}
suspend fun isLocalMode(): Boolean = localModeStore.get()
suspend fun setLocalMode() = localModeStore.set()
suspend fun clearLocalMode() = localModeStore.clear()
}
data class AuthSession(
val token: String,
val user: UserDto,
/** Expiration persistée du token (ms epoch) — null si inconnue. */
val expiresAt: Long? = null,
)
@@ -1,4 +1,4 @@
package com.vaultdrop.mobile.auth package com.kazier.mobile.auth
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
@@ -0,0 +1,41 @@
package com.kazier.mobile.auth
import com.kazier.mobile.data.remote.dto.UserDto
/**
* Persistance du token paseto, du profil compte et de l'expiration du token
* (claim `expires_at` du login, TTL 7 j). Implémentation : [SecureTokenStore]
* (Keystore + AES, jamais en clair dans SQLite).
*
* Les identifiants (username + password) sont persistés à part pour le
* re-login silencieux sur 401 (lot 3) : ils survivent à la purge du token
* ([clear] ne les touche pas) et ne tombent qu'au sign-out explicite
* ([clearCredentials]) ou quand le serveur les rejette (401 au re-login).
*/
interface TokenStore {
fun getToken(): String?
fun getUser(): UserDto?
/** Expiration du token (ms epoch, `expires_at` du login) — null si inconnue. */
fun getExpiresAt(): Long?
fun save(token: String, user: UserDto, expiresAt: Long?)
/** Purge token + compte + expiration — jamais les identifiants. */
fun clear()
/** Identifiants du re-login silencieux — null si jamais connectés. */
fun getCredentials(): Credentials?
fun saveCredentials(username: String, password: String)
fun clearCredentials()
}
/** Identifiants persistés (chiffrés) pour le re-login silencieux. */
data class Credentials(
val username: String,
val password: String,
)
@@ -0,0 +1,55 @@
package com.kazier.mobile.data.local
import androidx.room.Database
import androidx.room.RoomDatabase
import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.dao.ResourcePermissionDao
import com.kazier.mobile.data.local.dao.ScanDao
import com.kazier.mobile.data.local.dao.UserPreferenceDao
import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.ResourcePermissionEntity
import com.kazier.mobile.data.local.entity.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.local.entity.UserPreferenceEntity
/*
* DB SQLite locale, `dot.db` (même nom que la version Expo).
* v1: folders ; v2: user_preferences ; v3: files ; v4: category sur files ;
* v5: created_in_app sur folders ; v6: processed sur files (mode review) ;
* v7: pending_operations (outbox) ; v8: scan_sessions + scan_pages (scanner) ;
* v9: content sur files (corps des notes créées dans l'app) ;
* v10: ocr_text sur files (extrait OCR serveur persisté localement) ;
* v11: ocr_attempts + ocr_queued_at sur files (driver OCR auto côté client —
* compteur d'échecs terminaux ≤ 3, marqueur « en cours » de l'upload).
* v12: device_id sur pending_operations + unicité UNIQUE(device_id,
* operation_id) (contrat outbox docs/api-v1.md §6.1).
* v13: index composites files(exists, processed, sync_status) et
* pending_operations(resource_id, operation, status) (requêtes review/OCR/gates).
* v14: parent_resource_id sur pending_operations (cascade P8).
* v15: backfill exists NULL→1 sur folders/files (M13).
* v16: table resource_permissions (cache snapshot, M27).
*/
@Database(
entities = [
FolderEntity::class, UserPreferenceEntity::class, FileEntity::class,
PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class,
ResourcePermissionEntity::class,
],
version = 16,
// m19 : schéma exporté (`app/schemas/`) — toute dérive non migrée casse
// la compilation au lieu de briqueter les utilisateurs au démarrage.
exportSchema = true,
)
abstract class AppDatabase : RoomDatabase() {
abstract fun folderDao(): FolderDao
abstract fun userPreferenceDao(): UserPreferenceDao
abstract fun fileDao(): FileDao
abstract fun pendingOperationDao(): PendingOperationDao
abstract fun scanDao(): ScanDao
abstract fun resourcePermissionDao(): ResourcePermissionDao
}

Some files were not shown because too many files have changed in this diff Show More