29 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
226 changed files with 16495 additions and 2632 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"
-196
View File
@@ -1,196 +0,0 @@
# Pipeline GitLab pour Kazier — CI + Release.
#
# Prérequis runner :
# - Un runner avec executor Docker pour les jobs d'images (postgres service,
# docker:dind). Les jobs Android utilisent $ANDROID_IMAGE (défaut
# cimg/android) ; remplacez par l'image installée sur vos workers.
#
# Variables CI/CD à définir (Settings > CI/CD > Variables) :
# - RELEASE_KEYSTORE_B64 base64 du keystore release Android (jamais en clair)
# - SIGNING_STORE_PASSWORD SIGNING_KEY_ALIAS SIGNING_KEY_PASSWORD
# - GITLAB_API_TOKEN token (scope api, write_repository) pour créer la GitLab Release
# - DOCKERHUB_USER DOCKERHUB_TOKEN PAT Docker Hub (push public)
#
# Publication : à chaque tag vX.Y.Z → GitLab Release (APK attaché, latest +
# historique) + image $CI_REGISTRY + image Docker Hub (docker.io/thirdshop/kasier).
stages:
- lint
- test
- build
- docker
- release
variables:
GO_IMAGE: "golang:1.26-alpine"
POSTGRES_IMAGE: "postgres:17-alpine"
ANDROID_IMAGE: "cimg/android:2024.01"
GRADLE_USER_HOME: "$CI_PROJECT_DIR/.gradle-home"
CGO_ENABLED: "0"
DOCKERHUB_IMAGE: "docker.io/thirdshop/kasier"
GLAB_VERSION: "1.118.0"
default:
interruptible: true
retry:
max: 1
# ---------------------------------------------------------------- lint ----
lint-backend:
stage: lint
image: $GO_IMAGE
script:
- go mod download
- go vet ./...
- go install honnef.co/go/tools/cmd/staticcheck@latest && staticcheck ./...
lint-mobile:
stage: lint
image: $ANDROID_IMAGE
cache:
key: gradle-cache
paths:
- .gradle-home/caches
- .gradle-home/wrapper
script:
- cd mobile-kotlin && ./gradlew :app:lint -q
# ---------------------------------------------------------------- test ----
test-backend:
stage: test
image: $GO_IMAGE
services:
- name: $POSTGRES_IMAGE
alias: postgres
variables:
POSTGRES_DB: kazier_test
POSTGRES_USER: kazier
POSTGRES_PASSWORD: kazier
TEST_DATABASE_URL: postgres://kazier:kazier@postgres:5432/kazier_test?sslmode=disable
script:
- mkdir -p .go-cache && export GOPATH="$CI_PROJECT_DIR/.go-cache"
- go mod download
- go test ./...
cache:
key: go-cache
paths:
- .go-cache
test-mobile:
stage: test
image: $ANDROID_IMAGE
cache:
key: gradle-cache
paths:
- .gradle-home/caches
- .gradle-home/wrapper
script:
- cd mobile-kotlin && ./gradlew :app:testDebugUnitTest -q
# ---------------------------------------------------------------- build ----
build-backend:
stage: build
image: $GO_IMAGE
script:
- export VERSION=$(cat VERSION)
- mkdir -p backend/bin
- cd backend && 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
artifacts:
paths:
- backend/bin/kazier-server
expire_in: 1 week
# --------------------------------------------------------------- docker ----
docker:
stage: docker
image: docker:27
services:
- name: docker:27-dind
alias: docker
variables:
DOCKER_HOST: tcp://docker:2375
DOCKER_TLS_CERTDIR: ""
IMAGE_TAG: "$CI_COMMIT_TAG"
script:
- export IMAGE_TAG="${IMAGE_TAG:-$CI_COMMIT_REF_SLUG}"
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
- docker build
--build-arg VERSION="$(cat VERSION)"
--build-arg BUILD_DATE="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-t "$CI_REGISTRY_IMAGE:$IMAGE_TAG"
./backend
- docker push "$CI_REGISTRY_IMAGE:$IMAGE_TAG"
- docker run --rm "$CI_REGISTRY_IMAGE:$IMAGE_TAG" --version
needs: ["build-backend"]
rules:
- if: $CI_COMMIT_TAG
- if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
# -------------------------------------------------------------- release ----
release-apk:
stage: release
image: $ANDROID_IMAGE
cache:
key: gradle-cache
paths:
- .gradle-home/caches
- .gradle-home/wrapper
script:
- export VERSION=$(cat VERSION)
- cd mobile-kotlin
- |
if [ -n "${RELEASE_KEYSTORE_B64:-}" ]; then
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
else
echo "RELEASE_KEYSTORE_B64 manquant — release non signée." >&2
exit 1
fi
- ./gradlew :app:assembleRelease -q
- cd "$CI_PROJECT_DIR"
- |
# glab : création de la GitLab Release + upload de l'APK en asset.
curl -sSLf \
"https://gitlab.com/gitlab-org/cli/-/releases/v${GLAB_VERSION}/downloads/glab_${GLAB_VERSION}_linux_amd64.tar.gz" \
| tar xz --strip-components=1 -C /usr/local/bin bin/glab
- glab --version
- export GITLAB_TOKEN="$GITLAB_API_TOKEN"
- glab release create "v$VERSION"
--name "Kazier v$VERSION"
--notes-file CHANGELOG.md
"mobile-kotlin/app/build/outputs/apk/release/app-release.apk"
needs: ["docker"]
rules:
- if: $CI_COMMIT_TAG
release-docker:
stage: release
image: docker:27
services:
- name: docker:27-dind
alias: docker
variables:
DOCKER_HOST: tcp://docker:2375
DOCKER_TLS_CERTDIR: ""
script:
- export VERSION=$(cat VERSION)
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
- docker pull "$CI_REGISTRY_IMAGE:$CI_COMMIT_TAG"
- |
: "${DOCKERHUB_USER:?DOCKERHUB_USER manquant}"
: "${DOCKERHUB_TOKEN:?DOCKERHUB_TOKEN manquant}"
echo "$DOCKERHUB_TOKEN" | docker login -u "$DOCKERHUB_USER" --password-stdin docker.io
IMAGE="$DOCKERHUB_IMAGE"
docker tag "$CI_REGISTRY_IMAGE:$CI_COMMIT_TAG" "$IMAGE:$CI_COMMIT_TAG"
docker tag "$CI_REGISTRY_IMAGE:$CI_COMMIT_TAG" "$IMAGE:latest"
docker push "$IMAGE:$CI_COMMIT_TAG"
docker push "$IMAGE:latest"
needs: ["docker"]
rules:
- if: $CI_COMMIT_TAG
+17 -15
View File
@@ -2,7 +2,7 @@
## 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": "..." } }`
@@ -52,39 +52,41 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- 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`) - 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
+7 -2
View File
@@ -5,10 +5,12 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
## [Unreleased] ## [Unreleased]
### Changé ## [1.0.0] - 2026-09-25
- **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é.
### Ajouté ### 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. - 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. - `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é). - Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé).
@@ -17,6 +19,9 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
- Licence AGPLv3, badge README, `CHANGELOG.md`. - Licence AGPLv3, badge README, `CHANGELOG.md`.
- Versioning Android aligné sur le `VERSION` racine (versionCode dérivé). - 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é ### 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. - 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). - `.gitignore` racine (uploads, binaires, keystore, artifacts).
+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.
+1 -1
View File
@@ -29,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 -1
View File
@@ -1 +1 @@
0.1.0 1.0.0
+1 -1
View File
@@ -34,7 +34,7 @@ LABEL org.opencontainers.image.title="kazier-server" \
org.opencontainers.image.description="Kazier backend API (Go/Gin + PostgreSQL) — local-first document vault" \ org.opencontainers.image.description="Kazier backend API (Go/Gin + PostgreSQL) — local-first document vault" \
org.opencontainers.image.version="${VERSION}" \ org.opencontainers.image.version="${VERSION}" \
org.opencontainers.image.licenses="AGPL-3.0-only" \ org.opencontainers.image.licenses="AGPL-3.0-only" \
org.opencontainers.image.source="https://gitlab.thirdshop.fr/thirdshop/kasier" \ org.opencontainers.image.source="https://gitea.thirdshop.fr/thirdshop/kazier" \
org.opencontainers.image.url="https://thirdshop.fr/en/applications/kazier/" \ org.opencontainers.image.url="https://thirdshop.fr/en/applications/kazier/" \
org.opencontainers.image.created="${BUILD_DATE}" \ org.opencontainers.image.created="${BUILD_DATE}" \
org.opencontainers.image.revision="" org.opencontainers.image.revision=""
+45 -6
View File
@@ -8,6 +8,7 @@ import (
"net/http" "net/http"
"os" "os"
"os/signal" "os/signal"
"sync"
"syscall" "syscall"
"time" "time"
@@ -41,14 +42,19 @@ func main() {
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 {
@@ -59,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(
@@ -74,7 +91,15 @@ func main() {
defer stop() defer stop()
// Worker OCR borné (OCR_WORKERS) : file `ocr_jobs`, hors request handlers. // Worker OCR borné (OCR_WORKERS) : file `ocr_jobs`, hors request handlers.
go handlers.Ocr.Run(ctx, cfg.OcrWorkers) // 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) log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers)
srv := &http.Server{ srv := &http.Server{
@@ -95,5 +120,19 @@ func main() {
if err := srv.Shutdown(shutdownCtx); err != nil { if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("shutdown: %v", err) 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") log.Println("arrêt propre")
} }
+24 -3
View File
@@ -13,11 +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",
"GET /api/v1/files/:id/ocr",
"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",
@@ -44,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")
}
}
}
+43 -1
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"
) )
@@ -19,6 +21,21 @@ type ApplicationConfig struct {
AdminPassword string AdminPassword string
} }
// 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) { func LoadApplicationConfig() (*ApplicationConfig, error) {
// .env optionnel — les défauts suffisent pour le dev local. // .env optionnel — les défauts suffisent pour le dev local.
@@ -28,16 +45,33 @@ func LoadApplicationConfig() (*ApplicationConfig, error) {
if err != nil { if err != nil {
return nil, err 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 nil, err return nil, err
} }
if maxSize < 1 || maxSize > 1024 {
return nil, fmt.Errorf("MAX_FILE_SIZE_MB hors plage 1-1024: %d", maxSize)
}
ocrWorkers, err := getInt("OCR_WORKERS", 2) ocrWorkers, err := getInt("OCR_WORKERS", 2)
if err != nil { if err != nil {
return nil, err 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{ return &ApplicationConfig{
Port: port, Port: port,
@@ -46,13 +80,21 @@ func LoadApplicationConfig() (*ApplicationConfig, error) {
MaxFileSizeMB: int64(maxSize), MaxFileSizeMB: int64(maxSize),
OcrLang: get("OCR_LANG", "fra+eng"), OcrLang: get("OCR_LANG", "fra+eng"),
OcrWorkers: ocrWorkers, OcrWorkers: ocrWorkers,
AuthSecret: get("AUTH_SECRET", "dev-secret-change-me"), AuthSecret: authSecret,
AdminUsername: get("ADMIN_USERNAME", ""), AdminUsername: get("ADMIN_USERNAME", ""),
AdminPassword: get("ADMIN_PASSWORD", ""), AdminPassword: get("ADMIN_PASSWORD", ""),
}, nil }, 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 == "" {
+41 -3
View File
@@ -10,6 +10,7 @@ func clearEnv(t *testing.T) {
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", "OCR_WORKERS", "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, "")
} }
@@ -40,9 +41,12 @@ func TestLoadApplicationDefaults(t *testing.T) {
if cfg.OcrWorkers != 2 { if cfg.OcrWorkers != 2 {
t.Errorf("OcrWorkers = %d, attendu 2", cfg.OcrWorkers) t.Errorf("OcrWorkers = %d, attendu 2", cfg.OcrWorkers)
} }
if cfg.AuthSecret != "dev-secret-change-me" { 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)
} }
@@ -56,7 +60,7 @@ func TestLoadApplicationEnvOverrides(t *testing.T) {
t.Setenv("UPLOAD_DIR", "/tmp/up") t.Setenv("UPLOAD_DIR", "/tmp/up")
t.Setenv("OCR_LANG", "eng") t.Setenv("OCR_LANG", "eng")
t.Setenv("OCR_WORKERS", "4") t.Setenv("OCR_WORKERS", "4")
t.Setenv("AUTH_SECRET", "super-secret") 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")
@@ -65,12 +69,46 @@ func TestLoadApplicationEnvOverrides(t *testing.T) {
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.OcrWorkers != 4 || 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)
@@ -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 @@
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}$');
+68 -5
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://kazier:kazier@localhost:5432/kazier_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()
}
+4 -8
View File
@@ -4,7 +4,6 @@ import (
"database/sql" "database/sql"
"fmt" "fmt"
"net/url" "net/url"
"os"
"strings" "strings"
"testing" "testing"
@@ -16,19 +15,16 @@ import (
// 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://kazier:kazier@localhost:5432/kazier_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)
+79 -8
View File
@@ -4,12 +4,12 @@ import (
"errors" "errors"
"net/http" "net/http"
"strings" "strings"
"sync"
"time" "time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/pkg/auth"
"github.com/kazier/backend/pkg/passwd" "github.com/kazier/backend/pkg/passwd"
"github.com/kazier/backend/repository" "github.com/kazier/backend/repository"
"github.com/kazier/backend/service" "github.com/kazier/backend/service"
@@ -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,
+70 -3
View File
@@ -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())
} }
} }
+65 -1
View File
@@ -1,7 +1,10 @@
package handlers package handlers
import ( import (
"net/http"
"regexp" "regexp"
"sync"
"time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api" "github.com/kazier/backend/pkg/api"
@@ -9,12 +12,65 @@ import (
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
+81 -16
View File
@@ -8,17 +8,38 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/kazier/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
@@ -82,6 +107,33 @@ func FilesGetOcr(c *gin.Context) {
api.OK(c, dto) 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")
@@ -108,6 +160,10 @@ 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 // resourceId optionnel : cible un fichier déjà connu (metadata-only de
// l'outbox) pour lui attacher ses octets physiques (ex. OCR serveur). // l'outbox) pour lui attacher ses octets physiques (ex. OCR serveur).
resourceID := c.PostForm("resourceId") resourceID := c.PostForm("resourceId")
@@ -134,6 +190,12 @@ func FilesUpload(c *gin.Context) {
dto, err := Store.Upload(userID, file, folderID, resourceID) 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
} }
@@ -165,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 {
+202 -5
View File
@@ -73,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()
@@ -517,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, "")
@@ -633,3 +634,199 @@ func TestFilesGetOcrOwnerShareAndScoping(t *testing.T) {
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/ocr", ownerToken, nil, "") rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/ocr", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "ocr-invalid-id") 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")
}
+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)
}
}
+33 -1
View File
@@ -2,6 +2,7 @@ package handlers
import ( import (
"errors" "errors"
"log"
"net/http" "net/http"
"strings" "strings"
@@ -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())
}
}
+1
View File
@@ -40,6 +40,7 @@ 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 // Worker OCR borné — le handler n'enfile plus que le job, le traitement
+8 -1
View File
@@ -25,11 +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/folders", FoldersList)
protected.GET("/files/:id", FilesGet) protected.GET("/files/:id", FilesGet)
protected.GET("/files/:id/ocr", FilesGetOcr) 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.DELETE("/files/:id", FilesDelete)
protected.GET("/files/folders", FoldersList)
protected.POST("/files/upload", FilesUpload) protected.POST("/files/upload", FilesUpload)
protected.GET("/users/resolve", ResolveUser) protected.GET("/users/resolve", ResolveUser)
+11 -1
View File
@@ -1,6 +1,7 @@
package handlers package handlers
import ( import (
"errors"
"net/http" "net/http"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@@ -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
} }
+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)
}
+9 -1
View File
@@ -2,6 +2,7 @@ package handlers
import ( import (
"errors" "errors"
"log"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api" "github.com/kazier/backend/pkg/api"
@@ -28,6 +29,13 @@ func writeError(c *gin.Context, err error) {
case errors.Is(err, service.ErrFileTooLarge): 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")
} }
} }
+37 -4
View File
@@ -2,6 +2,7 @@ package handlers
import ( import (
"net/http" "net/http"
"strconv"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@@ -9,10 +10,37 @@ import (
"github.com/kazier/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 {
+14
View File
@@ -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()
+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("kazier-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
} }
+10
View File
@@ -1,6 +1,7 @@
package repository package repository
import ( import (
"errors"
"testing" "testing"
"github.com/kazier/backend/dbtest" "github.com/kazier/backend/dbtest"
@@ -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)
}
}
+50 -11
View File
@@ -22,6 +22,12 @@ var ErrJobNotFound = errors.New("ocr job not found")
// ErrNoQueuedJobs marks an OCR queue drained (no job to claim). // ErrNoQueuedJobs marks an OCR queue drained (no job to claim).
var ErrNoQueuedJobs = errors.New("no queued ocr jobs") 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 {
@@ -58,12 +64,22 @@ 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 // ClaimNext atomically picks the oldest queued job (FIFO) and moves it to
@@ -96,12 +112,15 @@ func (o *OcrJobs) ClaimNext() (OcrJobRow, error) {
// ResetStaleProcessing requeues jobs stuck in `processing` (worker crash / // ResetStaleProcessing requeues jobs stuck in `processing` (worker crash /
// processus redémarré) et plus vieux que `olderThan`. Retourne le nb de jobs // processus redémarré) et plus vieux que `olderThan`. Retourne le nb de jobs
// requeued. // 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) { func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) {
res, err := o.DB.Exec( res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'queued', started_at = NULL `UPDATE ocr_jobs SET status = 'queued', started_at = NULL
WHERE status = 'processing' AND started_at < $1`, WHERE status = 'processing'
time.Now().Add(-olderThan), AND (started_at IS NULL OR started_at < NOW() - ($1::bigint * INTERVAL '1 millisecond'))`,
olderThan.Milliseconds(),
) )
if err != nil { if err != nil {
return 0, err return 0, err
@@ -110,19 +129,39 @@ func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) {
} }
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
} }
+90
View File
@@ -67,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)
} }
@@ -76,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()
@@ -179,3 +248,24 @@ func TestOcrJobsResetStaleProcessing(t *testing.T) {
t.Errorf("status après reset = %q, attendu queued", row.Status) 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
} }
+120 -13
View File
@@ -1,7 +1,6 @@
package repository package repository
import ( import (
"encoding/json"
"errors" "errors"
"testing" "testing"
@@ -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)
} }
} }
+122 -48
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
@@ -108,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
@@ -270,6 +285,26 @@ func (r *Resources) GetResourceOwner(resourceID string) (string, error) {
return ownerID, err 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(
@@ -369,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
} }
@@ -402,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()
@@ -425,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()
@@ -519,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`,
+150
View File
@@ -233,6 +233,156 @@ func TestListOwnedDelta(t *testing.T) {
} }
} }
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) { func TestUpdateOcrTextAndReadBack(t *testing.T) {
repo := newTestResources(t) repo := newTestResources(t)
owner := NewID() owner := NewID()
+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) {
+22 -2
View File
@@ -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)
} }
} }
+3 -1
View File
@@ -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 {
+26
View File
@@ -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/kazier/backend/models"
func (s *Services) CreateFolder(folderName string, destination *models.Document) (*models.Document, error) {
directory, err := models.NewDocument(folderName, models.DIRECTORY, 1)
if err != nil {
return nil, err
}
return directory, nil
}
-34
View File
@@ -1,34 +0,0 @@
package service
import (
"errors"
"fmt"
"github.com/kazier/backend/models"
)
func (s *Services) MoveDocumentIntoDocument(from *models.Document, to *models.Document) error {
if from.UUID == nil {
return errors.New(models.ERROR_DOCUMENT_NOT_PERCISTED)
}
if to.Type != models.DIRECTORY {
return errors.New("the destination document must be a directory")
}
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, from); !canEdit {
return errors.New("you cannot edit this folder")
}
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, to); !canEdit {
return errors.New("you cannot 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
}
-62
View File
@@ -1,62 +0,0 @@
package service
import (
"testing"
"github.com/kazier/backend/models"
)
func TestMoveDocument(t *testing.T) {
userAntoine, err := models.NewUser("antoine")
if err != nil {
t.Fatalf("creating antoine user: %v", err)
}
fakeUUID := "dsqdsq"
document, err := models.NewDocument("test.pdf", models.FILE, 1)
if err != nil {
t.Fatalf("creating document: %v", err)
}
document.UUID = &fakeUUID
folder, err := models.NewDocument("orga", models.DIRECTORY, 1)
if err != nil {
t.Fatalf("creating folder: %v", err)
}
folder.UUID = &fakeUUID
service := New(userAntoine)
if err := service.MoveDocumentIntoDocument(document, folder); err != nil {
t.Error(err)
}
}
func TestMoveDocumentToAFile(t *testing.T) {
userAntoine, err := models.NewUser("antoine")
if err != nil {
t.Fatalf("creating antoine user: %v", err)
}
document, err := models.NewDocument("test.pdf", models.FILE, 1)
if err != nil {
t.Fatalf("creating document: %v", err)
}
notAFolder, err := models.NewDocument("orga", models.FILE, 1)
if err != nil {
t.Fatalf("creating file: %v", err)
}
service := New(userAntoine)
err = service.MoveDocumentIntoDocument(document, notAFolder)
if err == nil {
t.Error(err)
}
}
+79 -11
View File
@@ -3,8 +3,11 @@ package service
import ( import (
"context" "context"
"errors" "errors"
"fmt"
"log" "log"
"os"
"path/filepath" "path/filepath"
"regexp"
"strings" "strings"
"sync" "sync"
"time" "time"
@@ -41,7 +44,29 @@ type Ocr struct {
} }
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, StaleAfter: StaleClaimTimeout} return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: normalizeOcrLang(lang), Engine: engine, StaleAfter: StaleClaimTimeout}
}
var (
// ocrLangPattern : whitelist OCR_LANG (A12) — lettres Tesseract + `+`
// 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 // Create valide la ressource (ownership par user) et l'enfile uniquement
@@ -110,44 +135,87 @@ func (o *Ocr) workerLoop(ctx context.Context) {
} }
// process exécute l'extraction pour un job déjà réclamé (`processing`). // 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) { 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) userID, err := o.Repository.Resources.GetResourceOwner(row.FileID)
if err != nil { if err != nil {
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable") fail("file not readable")
return return
} }
path, err := o.physicalPath(userID, row.FileID) path, err := o.physicalPath(userID, row.FileID)
if err != nil { if err != nil {
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "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(row.DeviceID, row.ID, err.Error()) fail(err.Error())
return return
} }
_ = o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text)
// Le texte atterrit sur la ressource (updated_at bumpé) : consultable par // Le texte atterrit sur la ressource (updated_at bumpé) : consultable par
// tous les devices du user et les grantees via GET /files/:id/ocr. SILENCIEUX // tous les devices du user et les grantees via GET /files/:id/ocr.
// (hôte déjà supprimé ou lock d'écriture) : le job reste source d'historique.
if trimmed := strings.TrimSpace(text); trimmed != "" { if trimmed := strings.TrimSpace(text); trimmed != "" {
if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil { if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil {
log.Printf("ocr: persiste ocr_text de %s: %v", row.FileID, err) 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
} }
+70
View File
@@ -94,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"})
+247 -21
View File
@@ -4,9 +4,11 @@ import (
"errors" "errors"
"fmt" "fmt"
"io" "io"
"log"
"mime/multipart" "mime/multipart"
"os" "os"
"path/filepath" "path/filepath"
"regexp"
"strings" "strings"
"time" "time"
@@ -16,6 +18,10 @@ import (
// ErrFileTooLarge signals an upload above MaxFileSize. // ErrFileTooLarge signals an upload above MaxFileSize.
var ErrFileTooLarge = 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 {
ID string `json:"id"` ID string `json:"id"`
@@ -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 {
@@ -80,6 +146,66 @@ type FileOcrDTO struct {
UpdatedAt string `json:"updatedAt,omitempty"` 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 // 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). // shared). Absent text → Text empty ("") with 200 (the caller decides).
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) { func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
@@ -132,66 +258,166 @@ func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDT
// rename, never a move, never a duplicate row. Unknown / foreign resource → // rename, never a move, never a duplicate row. Unknown / foreign resource →
// repo.ErrNotFound. // repo.ErrNotFound.
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) { func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
if file.Size > s.MaxFileSize { // Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des
return FileDTO{}, ErrFileTooLarge // 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 != "" targetExisting := resourceID != ""
if targetExisting { if targetExisting {
if !idPattern.MatchString(resourceID) {
return FileDTO{}, repository.ErrNotFound
}
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil { if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
return FileDTO{}, err return FileDTO{}, err
} }
} else { } else {
resourceID = repository.NewID() var err error
resourceID, err = repository.NewIDErr()
if err != nil {
return FileDTO{}, err
}
} }
extension := strings.TrimPrefix(filepath.Ext(file.Filename), ".") name, err := sanitizeFileName(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
// enforce 0700 explicitement (cf. FEEDBACK A4).
if err := os.Chmod(destDir, 0o700); err != nil {
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
}
destPath := filepath.Join(destDir, resourceID+"."+extension) destName := resourceID
if err := copyMultipart(file, destPath); err != nil { if extension != "" {
destName = resourceID + "." + extension
}
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)
}
}
written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
if err != nil {
return FileDTO{}, err return FileDTO{}, err
} }
mimeType := file.Header.Get("Content-Type") mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
var err error var extPtr *string
if extension != "" {
extPtr = &extension
}
if targetExisting { if targetExisting {
err = s.Repo.UpdatePhysical(ownerID, resourceID, file.Size, &mimeType, &extension) err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
} else { } else {
err = s.Repo.InsertFile(ownerID, resourceID, file.Filename, folderID, file.Size, &mimeType, &extension) err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr)
} }
if err != nil { if err != nil {
_ = os.Remove(destPath) // 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 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) row, err := s.Repo.GetFile(ownerID, resourceID)
if err != nil { 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 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 {
+202
View File
@@ -6,6 +6,7 @@ import (
"mime/multipart" "mime/multipart"
"os" "os"
"path/filepath" "path/filepath"
"strings"
"testing" "testing"
"github.com/kazier/backend/repository" "github.com/kazier/backend/repository"
@@ -162,3 +163,204 @@ func TestUploadTargetUnknownIsNotFound(t *testing.T) {
t.Fatalf("upload inconnu : attendu ErrNotFound, got %v", err) 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/kazier/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
}
+168 -35
View File
@@ -3,6 +3,7 @@ package service
import ( import (
"encoding/json" "encoding/json"
"errors" "errors"
"log"
"regexp" "regexp"
"time" "time"
@@ -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 {
+283 -9
View File
@@ -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/kazier/backend/models"
)
func (s *Services) UploadDocument(file *string, destination *models.Document) error {
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, destination); !canEdit {
return fmt.Errorf("cannot edit document")
}
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:
+4 -1
View File
@@ -37,6 +37,7 @@ 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) | — |
@@ -44,6 +45,8 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
| 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/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[]` | — |
@@ -119,7 +122,7 @@ type FileOcr = { text: string; updatedAt?: string | null };
- `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>`
+25 -2
View File
@@ -21,9 +21,32 @@ 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
''' '''
+5
View File
@@ -84,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')"
]
}
}
@@ -41,6 +41,16 @@
<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>
@@ -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()
KazierTheme(theme = theme) { setContent {
KazierApp() val theme by themePreferenceStore.theme.collectAsStateWithLifecycle()
KazierTheme(theme = theme) {
KazierApp()
}
} }
} }
} }
@@ -15,16 +15,20 @@ import javax.inject.Singleton
* Persistance chiffrée du token paseto et du profil compte (Keystore + AES). * Persistance chiffrée du token paseto et du profil compte (Keystore + AES).
* Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est * Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est
* JAMAIS écrit en clair dans SQLite. * 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 @Singleton
class SecureTokenStore @Inject constructor( class SecureTokenStore @Inject constructor(
@ApplicationContext context: Context, @ApplicationContext private val context: Context,
moshi: Moshi, moshi: Moshi,
) { ) : TokenStore {
private val userAdapter: JsonAdapter<UserDto> = moshi.adapter(UserDto::class.java) private val userAdapter: JsonAdapter<UserDto> = moshi.adapter(UserDto::class.java)
private val prefs: SharedPreferences = run { private val prefs: SharedPreferences by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC) val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
EncryptedSharedPreferences.create( EncryptedSharedPreferences.create(
FILE_NAME, FILE_NAME,
@@ -35,29 +39,52 @@ class SecureTokenStore @Inject constructor(
) )
} }
fun getToken(): String? = prefs.getString(KEY_TOKEN, null) override fun getToken(): String? = prefs.getString(KEY_TOKEN, null)
fun getUser(): UserDto? { override fun getUser(): UserDto? {
val raw = prefs.getString(KEY_ACCOUNT, null) ?: return null val raw = prefs.getString(KEY_ACCOUNT, null) ?: return null
return runCatching { userAdapter.fromJson(raw) } return runCatching { userAdapter.fromJson(raw) }
.getOrNull() .getOrNull()
?.takeIf { it.id.isNotEmpty() && it.username.isNotEmpty() } ?.takeIf { it.id.isNotEmpty() && it.username.isNotEmpty() }
} }
fun save(token: String, user: UserDto) { 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() prefs.edit()
.putString(KEY_TOKEN, token) .putString(KEY_TOKEN, token)
.putString(KEY_ACCOUNT, userAdapter.toJson(user)) .putString(KEY_ACCOUNT, userAdapter.toJson(user))
.apply {
if (expiresAt != null) putLong(KEY_EXPIRES_AT, expiresAt) else remove(KEY_EXPIRES_AT)
}
.apply() .apply()
} }
fun clear() { override fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).apply() prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).remove(KEY_EXPIRES_AT).apply()
} }
companion object { companion object {
private const val FILE_NAME = "kazier_secure" private const val FILE_NAME = "kazier_secure"
private const val KEY_TOKEN = "kazier.auth_token" private const val KEY_TOKEN = "kazier.auth_token"
private const val KEY_ACCOUNT = "kazier.account" 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"
} }
} }
@@ -1,48 +1,203 @@
package com.kazier.mobile.auth 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.ApiClient
import com.kazier.mobile.data.remote.dto.LoginResponseDto 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.ActiveUserStore
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.LocalModeStore import com.kazier.mobile.domain.LocalModeStore
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton 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 * 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 * sécurisé, le miroir `active_user_id` et le token en mémoire lu par
* `AuthInterceptor`. Le drapeau « mode local » est persisté à part * `AuthInterceptor`. Le drapeau « mode local » est persisté à part
* ([LocalModeStore]) pour survivre aux redémarrages. * ([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 @Singleton
class SessionManager @Inject constructor( class SessionManager @Inject constructor(
private val secureTokenStore: SecureTokenStore, private val tokenStore: TokenStore,
private val activeUserStore: ActiveUserStore, private val activeUserStore: ActiveUserStore,
private val tokenProvider: TokenProvider, private val tokenProvider: TokenProvider,
private val localModeStore: LocalModeStore, private val localModeStore: LocalModeStore,
private val pendingOperationDao: PendingOperationDao,
private val apiClient: ApiClient,
private val authRepository: AuthRepository,
) { ) {
/** Restaure la session persistée (si présente), sinon null. */ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
suspend fun restore(): AuthSession? {
val token = secureTokenStore.getToken() ?: return null /** Single-flight du re-login : N 401 concurrents → 1 seul `POST /auth/login`. */
val user = secureTokenStore.getUser() ?: return null private val reloginMutex = Mutex()
tokenProvider.current = token
return AuthSession(token = token, user = user) 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() }
} }
suspend fun save(token: String, user: com.kazier.mobile.data.remote.dto.UserDto) { /** Restaure la session persistée (si présente), sinon null. */
secureTokenStore.save(token, user) 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) activeUserStore.set(user.id)
localModeStore.clear() localModeStore.clear()
tokenProvider.current = token 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() { suspend fun clear() = withContext(Dispatchers.IO) {
secureTokenStore.clear() tokenStore.clear()
tokenStore.clearCredentials()
activeUserStore.clear() activeUserStore.clear()
tokenProvider.current = null 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 isLocalMode(): Boolean = localModeStore.get()
suspend fun setLocalMode() = localModeStore.set() suspend fun setLocalMode() = localModeStore.set()
@@ -52,5 +207,7 @@ class SessionManager @Inject constructor(
data class AuthSession( data class AuthSession(
val token: String, val token: String,
val user: com.kazier.mobile.data.remote.dto.UserDto, val user: UserDto,
/** Expiration persistée du token (ms epoch) — null si inconnue. */
val expiresAt: Long? = null,
) )
@@ -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,
)
@@ -5,11 +5,13 @@ import androidx.room.RoomDatabase
import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao 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.ScanDao
import com.kazier.mobile.data.local.dao.UserPreferenceDao import com.kazier.mobile.data.local.dao.UserPreferenceDao
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.PendingOperationEntity 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.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanSessionEntity import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.local.entity.UserPreferenceEntity import com.kazier.mobile.data.local.entity.UserPreferenceEntity
@@ -23,14 +25,24 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity
* v10: ocr_text sur files (extrait OCR serveur persisté localement) ; * v10: ocr_text sur files (extrait OCR serveur persisté localement) ;
* v11: ocr_attempts + ocr_queued_at sur files (driver OCR auto côté client — * 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). * 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( @Database(
entities = [ entities = [
FolderEntity::class, UserPreferenceEntity::class, FileEntity::class, FolderEntity::class, UserPreferenceEntity::class, FileEntity::class,
PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class, PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class,
ResourcePermissionEntity::class,
], ],
version = 11, version = 16,
exportSchema = false, // 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 class AppDatabase : RoomDatabase() {
@@ -39,4 +51,5 @@ abstract class AppDatabase : RoomDatabase() {
abstract fun fileDao(): FileDao abstract fun fileDao(): FileDao
abstract fun pendingOperationDao(): PendingOperationDao abstract fun pendingOperationDao(): PendingOperationDao
abstract fun scanDao(): ScanDao abstract fun scanDao(): ScanDao
abstract fun resourcePermissionDao(): ResourcePermissionDao
} }
@@ -4,8 +4,11 @@ import com.kazier.mobile.data.local.entity.FileEntity
/** Date de référence d'un fichier : modification SAF quand dispo, sinon ajout local. */ /** Date de référence d'un fichier : modification SAF quand dispo, sinon ajout local. */
val FileEntity.referenceDate: Long val FileEntity.referenceDate: Long
get() = lastModified ?: addedAt get() {
val modified = lastModified
return if (modified != null && modified > 0L) modified else addedAt
}
/** Tri documents : même ordre que la grille d'accueil, du plus récent au plus vieux. */ /** Tri documents : même ordre que la grille d'accueil, du plus récent au plus vieux. */
fun List<FileEntity>.orderedByReferenceDateDesc(): List<FileEntity> = fun List<FileEntity>.orderedByReferenceDateDesc(): List<FileEntity> =
sortedByDescending { it.referenceDate } sortedWith(compareByDescending<FileEntity> { it.referenceDate }.thenBy { it.name })
@@ -0,0 +1,27 @@
package com.kazier.mobile.data.local
import java.text.Normalizer
import java.util.Locale
/**
* Échappe les jokers `LIKE` (`%`, `_`) et l'échappement lui-même (`\`) dans
* un fragment destiné à une requête `... LIKE ... ESCAPE '\'` (m5, m7).
* Sans ça, un `%`/`_` saisi (recherche) ou présent (uris SAF encodées
* `%3A…`) agit comme joker : match-all en recherche, sur-sélection au walk.
*/
internal fun String.escapeLike(): String =
replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
/**
* Normalise une saisie de recherche pour le matching insensible aux accents
* (suivi m7) : minuscules (ROOT, pas de surprise turque), décomposition NFD,
* suppression des diacritiques, ligatures `œ`/`æ` explicites (non décomposées
* par NFD). À appliquer AVANT [escapeLike] ; le SQL compare contre
* `name` normalisé de la même façon (chaîne de `REPLACE`, voir `FileDao`).
*/
internal fun String.normalizeSearch(): String =
lowercase(Locale.ROOT)
.let { Normalizer.normalize(it, Normalizer.Form.NFD) }
.replace(Regex("\\p{Mn}+"), "")
.replace("œ", "oe")
.replace("æ", "ae")
@@ -1,7 +1,10 @@
package com.kazier.mobile.data.local.dao package com.kazier.mobile.data.local.dao
import androidx.room.Dao import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query import androidx.room.Query
import androidx.room.Update
import androidx.room.Upsert import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
@@ -12,6 +15,21 @@ interface FileDao {
@Query("SELECT * FROM files ORDER BY name ASC") @Query("SELECT * FROM files ORDER BY name ASC")
suspend fun getAll(): List<FileEntity> suspend fun getAll(): List<FileEntity>
/**
* Lignes sous une racine SAF (m5) — voir `FolderDao.getUnderRoot`.
*/
@Query("SELECT * FROM files WHERE uri = :rootUri OR uri LIKE :escapedRoot || '/%' ESCAPE '\\'")
suspend fun getUnderRoot(rootUri: String, escapedRoot: String): List<FileEntity>
/**
* Repasse C4 : lignes déjà journalisées (`exists = 0`) dont les octets
* sont peut-être encore sur le disque (journal-first, crash ou refus SAF
* entre la transaction et la suppression physique). Borné pour ne jamais
* bloquer un tick de sync.
*/
@Query("SELECT * FROM files WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit")
suspend fun getMissingWithUri(limit: Int): List<FileEntity>
@Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC") @Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC")
fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>> fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>>
@@ -27,14 +45,29 @@ interface FileDao {
@Query("SELECT * FROM files WHERE uri = :uri LIMIT 1") @Query("SELECT * FROM files WHERE uri = :uri LIMIT 1")
suspend fun getByUri(uri: String): FileEntity? suspend fun getByUri(uri: String): FileEntity?
/**
* Recherche par nom (m7 + suivi accents) : `:query` arrive déjà échappé
* (`escapeLike`, `%`/`_` littéraux, pas des jokers) avec `ESCAPE '\'`.
* `COLLATE NOCASE` couvre la casse ASCII ; la deuxième branche compare
* `lower(name)` débarrassé de ses accents (chaîne de `REPLACE` FR — pas de
* colonne normalisée ni de migration) contre `:normQuery` (saisie passée
* par `normalizeSearch` + `escapeLike`). « ete » trouve « ÉTÉ ».
*/
@Query(""" @Query("""
SELECT * FROM files SELECT * FROM files
WHERE "exists" = 1 WHERE "exists" = 1
AND (:query IS NULL OR name LIKE '%' || :query || '%') AND (:query IS NULL OR name COLLATE NOCASE LIKE '%' || :query || '%' ESCAPE '\'
OR REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
lower(name),
'œ','oe'),'æ','ae'),'ç','c'),'à','a'),'â','a'),'ä','a'),
'é','e'),'è','e'),'ê','e'),'ë','e'),'î','i'),'ï','i'),
'ô','o'),'ö','o'),'ù','u'),'û','u'),'ü','u'),'ÿ','y')
LIKE '%' || :normQuery || '%' ESCAPE '\')
AND (:category IS NULL OR category = :category) AND (:category IS NULL OR category = :category)
ORDER BY name ASC ORDER BY name ASC
""") """)
fun searchWithFilters(query: String?, category: String?): Flow<List<FileEntity>> fun searchWithFilters(query: String?, normQuery: String?, category: String?): Flow<List<FileEntity>>
@Query(""" @Query("""
SELECT * FROM files SELECT * FROM files
@@ -48,6 +81,19 @@ interface FileDao {
@Upsert @Upsert
suspend fun upsert(file: FileEntity) suspend fun upsert(file: FileEntity)
/**
* Insert sans écrasement, résolu sur TOUTES les contraintes uniques
* (`resource_id`, `uri`) — pas seulement la PK. Retourne le rowId, ou -1
* si une ligne existe déjà : le repository relit alors le gagnant et
* applique [update]. Deux walks/refresh concurrents ne lèvent jamais
* `SQLiteConstraintException`.
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insertIgnore(file: FileEntity): Long
@Update
suspend fun update(file: FileEntity)
@Query("UPDATE files SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId") @Query("UPDATE files SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId")
suspend fun markMissing(resourceId: String, updatedAt: Long) suspend fun markMissing(resourceId: String, updatedAt: Long)
@@ -86,8 +132,8 @@ interface FileDao {
@Query("UPDATE files SET folder_resource_id = :folderId, updated_at = :updatedAt WHERE resource_id IN (:resourceIds)") @Query("UPDATE files SET folder_resource_id = :folderId, updated_at = :updatedAt WHERE resource_id IN (:resourceIds)")
suspend fun moveToFolder(resourceIds: List<String>, folderId: String, updatedAt: Long) suspend fun moveToFolder(resourceIds: List<String>, folderId: String, updatedAt: Long)
@Query("UPDATE files SET uri = :uri WHERE resource_id = :resourceId") @Query("UPDATE files SET uri = :uri, updated_at = :updatedAt WHERE resource_id = :resourceId")
suspend fun updateUri(resourceId: String, uri: String?) suspend fun updateUri(resourceId: String, uri: String?, updatedAt: Long)
@Query("DELETE FROM files WHERE resource_id = :resourceId") @Query("DELETE FROM files WHERE resource_id = :resourceId")
suspend fun remove(resourceId: String) suspend fun remove(resourceId: String)
@@ -129,7 +175,10 @@ interface FileDao {
/** Candidate OCR auto : fichier `processed`, `local-cloud`, avec copie /** Candidate OCR auto : fichier `processed`, `local-cloud`, avec copie
* locale, format potentiellement extractible, jamais extrait, pas en cours * locale, format potentiellement extractible, jamais extrait, pas en cours
* et pas épuisé (< 3 échecs terminaux). Trié par dernier upload. */ * et pas épuisé (< 3 échecs terminaux). Trié par dernier upload.
*
* Les lignes pré-v4 sans `category` (NULL) restent éligibles sur la base
* de leur `mime_type`/`extension` (backfill logique, sans migration). */
@Query(""" @Query("""
SELECT * FROM files SELECT * FROM files
WHERE "exists" = 1 WHERE "exists" = 1
@@ -139,7 +188,16 @@ interface FileDao {
AND ocr_text IS NULL AND ocr_text IS NULL
AND ocr_attempts < 3 AND ocr_attempts < 3
AND ocr_queued_at IS NULL AND ocr_queued_at IS NULL
AND category IN ('PDF', 'IMAGE', 'TEXT') AND (
category IN ('PDF', 'IMAGE', 'TEXT')
OR (category IS NULL AND (
mime_type = 'application/pdf'
OR mime_type LIKE 'image/%'
OR mime_type LIKE 'text/%'
OR extension IN ('pdf', 'png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp',
'txt', 'md', 'html', 'xml', 'json')
))
)
ORDER BY COALESCE(last_modified, added_at) DESC, name ASC ORDER BY COALESCE(last_modified, added_at) DESC, name ASC
""") """)
suspend fun getOcrAutoCandidates(): List<FileEntity> suspend fun getOcrAutoCandidates(): List<FileEntity>
@@ -148,8 +206,10 @@ interface FileDao {
@Query("UPDATE files SET ocr_queued_at = :queuedAt, updated_at = :now WHERE resource_id = :resourceId") @Query("UPDATE files SET ocr_queued_at = :queuedAt, updated_at = :now WHERE resource_id = :resourceId")
suspend fun markOcrQueued(resourceId: String, queuedAt: Long, now: Long) suspend fun markOcrQueued(resourceId: String, queuedAt: Long, now: Long)
/** Levé du marqueur + reset du compteur d'échecs (succès / erreur transitoire). */ /** Levé du marqueur « en cours » (succès / erreur transitoire). Le
@Query("UPDATE files SET ocr_queued_at = NULL, ocr_attempts = 0, updated_at = :now WHERE resource_id = :resourceId") * compteur d'échecs est préservé : seul [markOcrFailure] l'incrémente,
* un succès durable passe par `updateOcrText` + `markOcrQueued` réarmé. */
@Query("UPDATE files SET ocr_queued_at = NULL, updated_at = :now WHERE resource_id = :resourceId")
suspend fun clearOcrQueued(resourceId: String, now: Long) suspend fun clearOcrQueued(resourceId: String, now: Long)
/** Échec terminal : +1 tentative, marqueur levé (ne rejoue pas à l'infini). */ /** Échec terminal : +1 tentative, marqueur levé (ne rejoue pas à l'infini). */
@@ -4,6 +4,7 @@ import androidx.room.Dao
import androidx.room.Insert import androidx.room.Insert
import androidx.room.OnConflictStrategy import androidx.room.OnConflictStrategy
import androidx.room.Query import androidx.room.Query
import androidx.room.Update
import androidx.room.Upsert import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
@@ -17,6 +18,22 @@ interface FolderDao {
@Query("SELECT * FROM folders ORDER BY name ASC") @Query("SELECT * FROM folders ORDER BY name ASC")
suspend fun getAll(): List<FolderEntity> suspend fun getAll(): List<FolderEntity>
/**
* Lignes sous une racine SAF (m5) : le walk et sa réconciliation ne
* scannent plus toute la table par racine. `:escapedRoot` est la racine
* avec `%`, `_`, `\` échappés côté appelant (`ESCAPE '\'`).
*/
@Query("SELECT * FROM folders WHERE uri = :rootUri OR uri LIKE :escapedRoot || '/%' ESCAPE '\\'")
suspend fun getUnderRoot(rootUri: String, escapedRoot: String): List<FolderEntity>
/**
* Repasse C4 (dossiers) : voir `FileDao.getMissingWithUri`. Un dossier
* n'est re-supprimé physiquement que si toute sa descendance Room est
* aussi `exists = 0` (jamais de suppression d'un arbre encore vivant).
*/
@Query("SELECT * FROM folders WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit")
suspend fun getMissingWithUri(limit: Int): List<FolderEntity>
/** Dossiers créés dans l'app (`created_in_app = 1`) — cibles du picker de déplacement. */ /** Dossiers créés dans l'app (`created_in_app = 1`) — cibles du picker de déplacement. */
@Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC") @Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC")
suspend fun getCreatedInApp(): List<FolderEntity> suspend fun getCreatedInApp(): List<FolderEntity>
@@ -50,6 +67,19 @@ interface FolderDao {
@Upsert @Upsert
suspend fun upsert(folder: FolderEntity) suspend fun upsert(folder: FolderEntity)
/**
* Insert sans écrasement, résolu sur TOUTES les contraintes uniques
* (`resource_id`, `uri`) — pas seulement la PK. Retourne le rowId, ou -1
* si une ligne existe déjà : le repository relit alors le gagnant et
* applique [update]. Deux walks concurrents ne lèvent jamais
* `SQLiteConstraintException`.
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insertIgnore(folder: FolderEntity): Long
@Update
suspend fun update(folder: FolderEntity)
@Insert(onConflict = OnConflictStrategy.REPLACE) @Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun upsertAll(folders: List<FolderEntity>) suspend fun upsertAll(folders: List<FolderEntity>)
@@ -27,19 +27,48 @@ interface PendingOperationDao {
@Query("UPDATE pending_operations SET status = 'synced', updated_at = :now WHERE id = :id") @Query("UPDATE pending_operations SET status = 'synced', updated_at = :now WHERE id = :id")
suspend fun markSynced(id: Long, now: Long) suspend fun markSynced(id: Long, now: Long)
/** Échec avec bump du compteur de tentatives (dead-letter après MAX_PENDING_ATTEMPTS). */ /**
* Échec définitif (dead-letter immédiate) ; `attempts` est un compteur
* diagnostic (bump), pas un seuil — il n'y a aucun `MAX_PENDING_ATTEMPTS` :
* une op `failed` n'est plus resélectionnée.
*/
@Query("UPDATE pending_operations SET status = 'failed', attempts = attempts + 1, updated_at = :now WHERE id = :id") @Query("UPDATE pending_operations SET status = 'failed', attempts = attempts + 1, updated_at = :now WHERE id = :id")
suspend fun markFailed(id: Long, now: Long) suspend fun markFailed(id: Long, now: Long)
/** /**
* Invalidation en cascade : un `create_resource` définitivement échoué rend * Invalidation en cascade : un `create_resource` définitivement échoué rend
* fautives toutes les ops en attente qui ciblent la même ressource (filles). * fautives toutes les ops en attente qui ciblent la même ressource, ainsi
* que les creates enfants (autre `resource_id`, liés via la colonne
* `parent_resource_id` — le walk émet parent avant enfant, cf. C6).
* Le repli `LIKE` sur le payload ne sert que les lignes pré-v14 sans
* colonne renseignée.
*/ */
@Query("UPDATE pending_operations SET status = 'failed', updated_at = :now WHERE resource_id = :resourceId AND status = 'pending'") @Query("""
UPDATE pending_operations SET status = 'failed', updated_at = :now
WHERE status = 'pending' AND (
resource_id = :resourceId
OR parent_resource_id = :resourceId
OR (parent_resource_id IS NULL AND payload LIKE '%"parentResourceId":"' || :resourceId || '"%')
)
""")
suspend fun failDescendants(resourceId: String, now: Long) suspend fun failDescendants(resourceId: String, now: Long)
/** Rétention : purge des ops synchronisées plus anciennes que `cutoff`. */ /**
@Query("DELETE FROM pending_operations WHERE status = 'synced' AND updated_at < :cutoff") * Rétention : purge des ops synchronisées plus anciennes que `cutoff`.
*
* Décision C3 — les `create_resource` synced ne sont JAMAIS purgés
* (tombstones) : les gates delete/create (`hasCreateOperation`,
* `countCreateOperations…`) et le backfill de placement sont fondés sur
* `pending+synced`. Purger un create casserait le gate delete (fantôme
* serveur indélébile) et ré-enqueue un create dupliqué au prochain
* `markProcessed`. Les autres ops synced (> 7j) sont purgées normalement.
*/
@Query("""
DELETE FROM pending_operations
WHERE status = 'synced'
AND updated_at < :cutoff
AND operation != 'create_resource'
""")
suspend fun purgeSynced(cutoff: Long) suspend fun purgeSynced(cutoff: Long)
/** /**
@@ -69,14 +98,85 @@ interface PendingOperationDao {
""") """)
suspend fun countCreateOperationsAnyType(resourceId: String): Int suspend fun countCreateOperationsAnyType(resourceId: String): Int
/**
* Annulation (M19) : supprime les `create_resource` encore `pending` pour
* cette ressource. Appelé quand la ressource disparaît localement
* (suppression, réconciliation du walk) AVANT que le serveur l'ait connue :
* pousser un create puis un delete serait du bruit — le serveur n'a rien
* à oublier. Les creates `synced` sont conservés (tombstones C3) : le gate
* delete reste fondé dessus.
*/
@Query("""
DELETE FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND status = 'pending'
""")
suspend fun deletePendingCreates(resourceId: String): Int
/**
* Un `create_resource` a-t-il déjà été POUSSÉ (synced) pour ce fichier ?
* Gate delete précis : après [deletePendingCreates], `hasCreateOperation`
* (pending+synced) y est équivalent — ce compteur l'exprime directement.
*/
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND resource_type = 'file'
AND status = 'synced'
""")
suspend fun countSyncedCreateOperations(resourceId: String): Int
/** Variante sans filtre `resource_type` (dossiers) de [countSyncedCreateOperations]. */
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND status = 'synced'
""")
suspend fun countSyncedCreateOperationsAnyType(resourceId: String): Int
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'") @Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'")
suspend fun countPending(): Int suspend fun countPending(): Int
/** Compteur diagnostique par statut (tests, badge « liste des sync »). */
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = :status")
suspend fun countByStatus(status: String): Int
/** /**
* Une op `move_resource` encore en attente de push existe-t-elle pour cette * Abandon de la file non poussée (C5) : supprime les ops `pending` et
* ressource ? L'antichambre outbox est alors la source de vérité du * `failed` — jamais les `synced`. Au changement de compte (sign-out, ou
* placement : ni le refresh serveur ni le walk SAF ne doivent écraser le * login d'un autre user), rejouer la file de A sous le token de B
* `folder_resource_id` local avant que le serveur ait accusé le move. * appliquerait ses mutations dans le scope de B (`NOT_FOUND`,
* `NAME_CONFLICT`, voire créations croisées). Les ops `synced` sont
* conservées : ce sont des tombstones (C3) fondant les gates
* delete/create et le backfill — elles ne sont plus jamais sélectionnées
* (`selectPending` ne lit que `pending`) donc sans risque de rejeu.
*/
@Query("DELETE FROM pending_operations WHERE status IN ('pending', 'failed')")
suspend fun deleteUnpushed(): Int
/**
* Un `delete_resource` est-il encore en attente de push pour cette
* ressource ? Le walk SAF ne doit alors jamais la ressusciter (`exists =
* 1`) : l'intention de suppression est déjà journalisée (ordre
* journal-first, C4) et la repasse physique va suivre. Sans ce garde, le
* walk réimporterait une ressource que le serveur s'apprête à supprimer.
*/
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'delete_resource'
AND status = 'pending'
""")
suspend fun countPendingDeleteOperations(resourceId: String): Int
/**
* Un `move_resource` est-il encore en attente de push ? Tant que l'op est
* pendante, le `folder_resource_id` local reflète la cible future : ni le
* refresh serveur (qui renvoie l'ancien dossier) ni le walk SAF (snapshot
* périmé) ne doivent l'écraser.
*/ */
@Query(""" @Query("""
SELECT COUNT(*) FROM pending_operations SELECT COUNT(*) FROM pending_operations
@@ -98,4 +198,19 @@ interface PendingOperationDao {
AND status IN ('pending', 'synced') AND status IN ('pending', 'synced')
""") """)
suspend fun countMoveOperations(resourceId: String): Int suspend fun countMoveOperations(resourceId: String): Int
/**
* Ops de partage encore en attente de push pour cette ressource
* (`share`, `update_share`, `revoke_share`, `create_link`, `revoke_link`).
* Le sheet de partage les affiche comme « en attente d'envoi » : la liste
* serveur ne les reflète qu'après le drain du worker.
*/
@Query("""
SELECT * FROM pending_operations
WHERE resource_id = :resourceId
AND operation IN ('share', 'update_share', 'revoke_share', 'create_link', 'revoke_link')
AND status = 'pending'
ORDER BY id ASC
""")
suspend fun pendingShareOps(resourceId: String): List<PendingOperationEntity>
} }
@@ -0,0 +1,30 @@
package com.kazier.mobile.data.local.dao
import androidx.room.Dao
import androidx.room.Query
import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.ResourcePermissionEntity
@Dao
interface ResourcePermissionDao {
@Upsert
suspend fun upsertAll(perms: List<ResourcePermissionEntity>)
@Query("SELECT * FROM resource_permissions WHERE resource_id = :resourceId LIMIT 1")
suspend fun getByResourceId(resourceId: String): ResourcePermissionEntity?
/** Grants périmés à masquer localement (`expires_at` passé). */
@Query("SELECT * FROM resource_permissions WHERE expires_at IS NOT NULL AND expires_at <= :now")
suspend fun getExpired(now: Long): List<ResourcePermissionEntity>
/**
* Convergence du pull complet : oublie les grants absents du snapshot
* (révocation/expiration côté serveur).
*/
@Query("DELETE FROM resource_permissions WHERE resource_id NOT IN (:snapshotIds)")
suspend fun deleteNotIn(snapshotIds: List<String>)
@Query("DELETE FROM resource_permissions")
suspend fun clear()
}
@@ -45,6 +45,9 @@ interface ScanDao {
@Query("DELETE FROM scan_pages WHERE id = :pageId AND session_id = :sessionId") @Query("DELETE FROM scan_pages WHERE id = :pageId AND session_id = :sessionId")
suspend fun deletePage(pageId: Long, sessionId: Long) suspend fun deletePage(pageId: Long, sessionId: Long)
@Query("DELETE FROM scan_sessions WHERE id = :sessionId")
suspend fun deleteSession(sessionId: Long)
@Query( @Query(
""" """
UPDATE scan_pages SET sort_order = CASE id UPDATE scan_pages SET sort_order = CASE id
@@ -61,4 +64,12 @@ interface ScanDao {
@Query("SELECT COUNT(*) FROM scan_pages WHERE session_id = :sessionId") @Query("SELECT COUNT(*) FROM scan_pages WHERE session_id = :sessionId")
suspend fun pageCount(sessionId: Long): Int suspend fun pageCount(sessionId: Long): Int
/**
* Plus grand `sort_order` de la session (NULL si vide) : l'ordre d'une
* nouvelle page est `MAX + 1`, jamais `COUNT` (qui collisionne après
* suppression : A,B → del A → C réutiliserait l'ordre de B).
*/
@Query("SELECT MAX(sort_order) FROM scan_pages WHERE session_id = :sessionId")
suspend fun maxSortOrder(sessionId: Long): Int?
} }
@@ -22,6 +22,7 @@ import androidx.room.PrimaryKey
Index(value = ["uri"], unique = true), Index(value = ["uri"], unique = true),
Index(value = ["folder_resource_id"]), Index(value = ["folder_resource_id"]),
Index(value = ["category"]), Index(value = ["category"]),
Index(value = ["exists", "processed", "sync_status"]),
], ],
) )
data class FileEntity( data class FileEntity(
@@ -41,8 +42,9 @@ data class FileEntity(
val size: Long, val size: Long,
@ColumnInfo(name = "mime_type") @ColumnInfo(name = "mime_type")
val mimeType: String? = null, val mimeType: String? = null,
// M13 : voir `FolderEntity.exists` — défaut 1, backfill en migration 14→15.
@ColumnInfo(name = "exists") @ColumnInfo(name = "exists")
val exists: Int? = null, val exists: Int? = 1,
@ColumnInfo(name = "last_modified") @ColumnInfo(name = "last_modified")
val lastModified: Long? = null, val lastModified: Long? = null,
@ColumnInfo(name = "owner_id") @ColumnInfo(name = "owner_id")
@@ -32,8 +32,11 @@ data class FolderEntity(
val uri: String? = null, val uri: String? = null,
@ColumnInfo(name = "name") @ColumnInfo(name = "name")
val name: String, val name: String,
// M13 : défaut 1 — une ligne sans `exists` explicite restait invisible
// des requêtes `WHERE exists = 1`. La colonne reste nullable côté schéma
// (pas de rewrite), le backfill NULL→1 est fait en migration 14→15.
@ColumnInfo(name = "exists") @ColumnInfo(name = "exists")
val exists: Int? = null, val exists: Int? = 1,
@ColumnInfo(name = "parent_resource_id") @ColumnInfo(name = "parent_resource_id")
val parentResourceId: String? = null, val parentResourceId: String? = null,
@ColumnInfo(name = "owner_id") @ColumnInfo(name = "owner_id")
@@ -20,14 +20,18 @@ import androidx.room.PrimaryKey
@Entity( @Entity(
tableName = "pending_operations", tableName = "pending_operations",
indices = [ indices = [
Index(value = ["operation_id"], unique = true), Index(value = ["device_id", "operation_id"], unique = true),
Index(value = ["status"]), Index(value = ["status"]),
Index(value = ["resource_id"]), Index(value = ["resource_id"]),
Index(value = ["resource_id", "operation", "status"]),
Index(value = ["parent_resource_id"]),
], ],
) )
data class PendingOperationEntity( data class PendingOperationEntity(
@PrimaryKey(autoGenerate = true) @PrimaryKey(autoGenerate = true)
val id: Long = 0L, val id: Long = 0L,
@ColumnInfo(name = "device_id")
val deviceId: String? = null,
@ColumnInfo(name = "operation_id") @ColumnInfo(name = "operation_id")
val operationId: String, val operationId: String,
@ColumnInfo(name = "ref_type") @ColumnInfo(name = "ref_type")
@@ -42,6 +46,15 @@ data class PendingOperationEntity(
val operation: String, val operation: String,
@ColumnInfo(name = "payload") @ColumnInfo(name = "payload")
val payload: String, val payload: String,
/**
* Lien parent→enfant dénormalisé (P8) : `resource_id` du dossier parent
* pour un `create_resource` avec parent (les enfants portent un autre
* `resource_id`). Évite de parser le JSON du payload (`LIKE`) pour la
* cascade d'invalidation — robuste au format de sérialisation Moshi.
* NULL pour les ops sans parent et les lignes pré-v14 (repli LIKE).
*/
@ColumnInfo(name = "parent_resource_id")
val parentResourceId: String? = null,
@ColumnInfo(name = "status") @ColumnInfo(name = "status")
val status: String = PendingOpStatus.PENDING, val status: String = PendingOpStatus.PENDING,
@ColumnInfo(name = "attempts") @ColumnInfo(name = "attempts")
@@ -0,0 +1,59 @@
package com.kazier.mobile.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey
/**
* Cache local du snapshot `GET /sync/permissions` (M27, docs/api-v1.md §6.2).
*
* Une ligne = la permission effective connue pour une ressource NON possédée
* (les ressources `owner` ne sont pas stockées : l'ownership se résout depuis
* les lignes `files`/`folders`). Fondement de [canAccess][com.kazier.mobile.data.repository.ShareRepository.canAccess]
* sans réseau : rang effectif, expiration du grant et fraîcheur du snapshot
* (TTL 24h → downgrade lecture seule).
*/
@Entity(
tableName = "resource_permissions",
indices = [
Index(value = ["expires_at"]),
],
)
data class ResourcePermissionEntity(
@PrimaryKey
@ColumnInfo(name = "resource_id")
val resourceId: String,
@ColumnInfo(name = "resource_type")
val resourceType: String,
@ColumnInfo(name = "effective_access")
val effectiveAccess: String,
@ColumnInfo(name = "owner_id")
val ownerId: String? = null,
@ColumnInfo(name = "shared_by_id")
val sharedById: String? = null,
/** Fin du grant, ms epoch ; null = jamais. */
@ColumnInfo(name = "expires_at")
val expiresAt: Long? = null,
/** Horodatage du snapshot serveur, ms epoch (TTL 24h). */
@ColumnInfo(name = "cached_at")
val cachedAt: Long,
@ColumnInfo(name = "updated_at")
val updatedAt: Long,
)
/** Rangs d'accès effectif — `viewer < commenter < editor < owner`. */
object AccessRank {
const val VIEWER = "viewer"
const val COMMENTER = "commenter"
const val EDITOR = "editor"
const val OWNER = "owner"
fun rank(access: String?): Int = when (access) {
OWNER -> 4
EDITOR -> 3
COMMENTER -> 2
VIEWER -> 1
else -> 0
}
}
@@ -26,6 +26,16 @@ import androidx.sqlite.db.SupportSQLiteDatabase
* l'app (fichier cloud-only, uri = NULL). Null pour les fichiers importés. * l'app (fichier cloud-only, uri = NULL). Null pour les fichiers importés.
* v10 : ajout colonne `ocr_text` sur `files` — extrait OCR serveur persisté * v10 : ajout colonne `ocr_text` sur `files` — extrait OCR serveur persisté
* localement (résultat d'un job `POST /ocr/jobs`, réaffichable sans relance). * localement (résultat d'un job `POST /ocr/jobs`, réaffichable sans relance).
* v11 : `ocr_attempts` + `ocr_queued_at` sur `files` (driver OCR auto).
* v12 : ajout colonne `device_id` sur `pending_operations` + unicité
* composite `UNIQUE(device_id, operation_id)` (contrat docs/api-v1.md §6.1) ;
* backfill depuis `user_preferences.device_user_id` pour les lignes existantes.
* v13 : index composites `files(exists, processed, sync_status)` (review +
* candidats OCR auto) et `pending_operations(resource_id, operation, status)`
* (gates outbox create/move) — requêtes à chaud sans full-table scan.
* v14 : colonne `parent_resource_id` sur `pending_operations` (cascade P8).
* v15 : backfill `exists` NULL→1 sur `folders`/`files` (M13) + défaut Kotlin 1.
* v16 : table `resource_permissions` (cache snapshot, M27) + index `expires_at`.
*/ */
object Migrations { object Migrations {
@@ -92,6 +102,14 @@ object Migrations {
db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0") db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0")
// Backlog = déjà traité : la file de review ne contient que les // Backlog = déjà traité : la file de review ne contient que les
// fichiers découverts après l'activation de la fonctionnalité. // fichiers découverts après l'activation de la fonctionnalité.
//
// Décision M11 (documentée, assumée) : aucun `create_resource`
// rétroactif n'est journalisé pour ce backlog — ces fichiers ne
// seront jamais poussés vers le serveur (ni vizibles en review).
// Un backfill applicatif créerait des doublons serveur pour les
// ressources déjà connues par d'autres chemins (scan, second
// device) sans moyen fiable de les distinguer : la perte silencieuse
// du backlog pré-v6 est préférée à une résurrection massive.
db.execSQL("UPDATE `files` SET `processed` = 1") db.execSQL("UPDATE `files` SET `processed` = 1")
} }
} }
@@ -181,7 +199,99 @@ object Migrations {
} }
} }
private val MIGRATION_11_12 = object : Migration(11, 12) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `device_id` TEXT")
// Backfill : les ops pré-v12 héritent du device courant (une seule
// identité device par base en pratique).
db.execSQL(
"""
UPDATE `pending_operations` SET `device_id` =
(SELECT `value` FROM `user_preferences` WHERE `key` = 'device_user_id')
WHERE `device_id` IS NULL
""".trimIndent(),
)
db.execSQL("DROP INDEX IF EXISTS `index_pending_operations_operation_id`")
db.execSQL(
"CREATE UNIQUE INDEX IF NOT EXISTS " +
"`index_pending_operations_device_id_operation_id` " +
"ON `pending_operations` (`device_id`, `operation_id`)",
)
}
}
private val MIGRATION_12_13 = object : Migration(12, 13) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` " +
"ON `files` (`exists`, `processed`, `sync_status`)",
)
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` " +
"ON `pending_operations` (`resource_id`, `operation`, `status`)",
)
}
}
/**
* P8 : colonne `parent_resource_id` dénormalisée (cascade sans parsing
* JSON). Les lignes pré-v14 gardent NULL et restent couvertes par le repli
* `LIKE` de `failDescendants` — pas de backfill (le `json_extract`
* SQLite n'est pas garanti sur tous les niveaux d'API).
*/
private val MIGRATION_13_14 = object : Migration(13, 14) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `parent_resource_id` TEXT")
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` " +
"ON `pending_operations` (`parent_resource_id`)",
)
}
}
/**
* M13 : backfill `exists` NULL→1 sur `folders` et `files`. Les lignes
* insérées sans `exists` explicite (défaut Kotlin `null` avant ce fix)
* étaient invisibles des requêtes `WHERE exists = 1` — elles
* réapparaissent comme présentes, état le plus sûr (le walk les
* re-marque `exists = 0` si elles ont vraiment disparu).
*/
private val MIGRATION_14_15 = object : Migration(14, 15) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("UPDATE `folders` SET `exists` = 1 WHERE `exists` IS NULL")
db.execSQL("UPDATE `files` SET `exists` = 1 WHERE `exists` IS NULL")
}
}
/**
* M27 : cache du snapshot permissions — table `resource_permissions`
* (rang effectif + expiration + fraîcheur, fondement de `canAccess`).
*/
private val MIGRATION_15_16 = object : Migration(15, 16) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL(
"""
CREATE TABLE IF NOT EXISTS `resource_permissions` (
`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`)
)
""".trimIndent(),
)
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` " +
"ON `resource_permissions` (`expires_at`)",
)
}
}
val ALL: Array<Migration> = arrayOf( val ALL: Array<Migration> = arrayOf(
MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13, MIGRATION_13_14, MIGRATION_14_15, MIGRATION_15_16,
) )
} }
@@ -1,22 +1,30 @@
package com.kazier.mobile.data.remote package com.kazier.mobile.data.remote
import com.squareup.moshi.JsonAdapter import com.squareup.moshi.JsonAdapter
import com.squareup.moshi.JsonDataException
import com.squareup.moshi.JsonEncodingException
import com.squareup.moshi.Moshi import com.squareup.moshi.Moshi
import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ApiErrorEnvelope import com.kazier.mobile.data.remote.dto.ApiErrorEnvelope
import com.kazier.mobile.data.remote.dto.ApiMeta
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
import com.kazier.mobile.data.remote.dto.FileDto import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.data.remote.dto.IdResultDto
import com.kazier.mobile.data.remote.dto.LoginRequestDto import com.kazier.mobile.data.remote.dto.LoginRequestDto
import com.kazier.mobile.data.remote.dto.LoginResponseDto import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.OcrJobDto import com.kazier.mobile.data.remote.dto.OcrJobDto
import com.kazier.mobile.data.remote.dto.OcrSubmitDto import com.kazier.mobile.data.remote.dto.OcrSubmitDto
import com.kazier.mobile.data.remote.dto.ResolvedUserDto import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.ShareGrantDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.SyncOpDto import com.kazier.mobile.data.remote.dto.SyncOpDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult import com.kazier.mobile.data.remote.dto.SyncOpsResult
import kotlin.coroutines.cancellation.CancellationException
import okhttp3.MultipartBody import okhttp3.MultipartBody
import okhttp3.MediaType.Companion.toMediaType import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody import okhttp3.RequestBody
@@ -44,7 +52,12 @@ class ApiException(
* - non-2xx → `ApiException` (code du body si présent, sinon `HTTP_<status>`), * - non-2xx → `ApiException` (code du body si présent, sinon `HTTP_<status>`),
* et un 401 sur un endpoint protégé déclenche `onUnauthorized` (sauf si * et un 401 sur un endpoint protégé déclenche `onUnauthorized` (sauf si
* `skipUnauthorizedHandling` — cas du login, où 401 = identifiants erronés) ; * `skipUnauthorizedHandling` — cas du login, où 401 = identifiants erronés) ;
* - 2xx sans `data` (ou corps illisible) → `INVALID_RESPONSE`. * - 2xx sans `data` (ou corps illisible) → `INVALID_RESPONSE` ;
* - un corps non parsable (Moshi) → `INVALID_RESPONSE`, jamais
* `NETWORK_ERROR` (pas de `retry()` infini sur contrat cassé) ;
* - `CancellationException` n'est jamais avalée (scopes/Worker sains).
* Les routes publiques (`/devices`, `/auth/login`, `/shares/links/:token`)
* désactivent le handling 401 : y purger la session serait faux.
*/ */
@Singleton @Singleton
class ApiClient @Inject constructor( class ApiClient @Inject constructor(
@@ -55,7 +68,7 @@ class ApiClient @Inject constructor(
private val errorEnvelopeAdapter: JsonAdapter<ApiErrorEnvelope> = private val errorEnvelopeAdapter: JsonAdapter<ApiErrorEnvelope> =
moshi.adapter(ApiErrorEnvelope::class.java) moshi.adapter(ApiErrorEnvelope::class.java)
/** Callback 401 (expiration/révocation) — branché par AuthViewModel. */ /** Callback 401 (expiration/révocation) — branché par SessionManager. */
@Volatile @Volatile
var onUnauthorized: (() -> Unit)? = null var onUnauthorized: (() -> Unit)? = null
@@ -64,8 +77,20 @@ class ApiClient @Inject constructor(
suspend fun listFiles(folderId: String? = null, page: Int? = null, pageSize: Int? = null): List<FileDto> = suspend fun listFiles(folderId: String? = null, page: Int? = null, pageSize: Int? = null): List<FileDto> =
unwrap({ apiService.listFiles(folderId, page, pageSize) }) unwrap({ apiService.listFiles(folderId, page, pageSize) })
/**
* Variante paginée exposant `meta` (page/pageSize/total) — seule base
* saine pour drainer un dossier au-delà de la 1re page (M21).
*/
suspend fun listFilesPaged(
folderId: String? = null,
page: Int? = null,
pageSize: Int? = null,
): Pair<List<FileDto>, ApiMeta?> =
unwrapWithMeta({ apiService.listFiles(folderId, page, pageSize) })
suspend fun registerDevice(deviceId: String): String = suspend fun registerDevice(deviceId: String): String =
unwrap({ apiService.registerDevice(DeviceRegistrationDto(deviceId)) }).deviceId unwrap({ apiService.registerDevice(DeviceRegistrationDto(deviceId)) },
skipUnauthorizedHandling = true).deviceId
suspend fun login(username: String, password: String, deviceId: String): LoginResponseDto = suspend fun login(username: String, password: String, deviceId: String): LoginResponseDto =
unwrap({ apiService.login(LoginRequestDto(username, password, deviceId)) }, unwrap({ apiService.login(LoginRequestDto(username, password, deviceId)) },
@@ -110,16 +135,149 @@ class ApiClient @Inject constructor(
suspend fun getFileOcr(fileId: String): FileOcrDto = suspend fun getFileOcr(fileId: String): FileOcrDto =
unwrap({ apiService.getFileOcr(fileId) }) unwrap({ apiService.getFileOcr(fileId) })
/** Détail serveur d'un fichier visible — `GET /files/:id`. */
suspend fun getFile(fileId: String): FileDto =
unwrap({ apiService.getFile(fileId) })
/** Suppression serveur — `DELETE /files/:id`, retourne l'id supprimé. */
suspend fun deleteFile(fileId: String): String =
unwrap({ apiService.deleteFile(fileId) }).id
/** Recherche serveur paginée — `GET /files/search?q=…` (+ `meta`). */
suspend fun searchFilesPaged(
query: String,
page: Int? = null,
pageSize: Int? = null,
): Pair<List<FileDto>, ApiMeta?> =
unwrapWithMeta({ apiService.searchFiles(query, page, pageSize) })
/** Rotation du mot de passe — `PATCH /users/me/password`. */
suspend fun changePassword(currentPassword: String, newPassword: String): String =
unwrap({ apiService.changePassword(ChangePasswordDto(currentPassword, newPassword)) }).id
/**
* Résolution anonyme d'un lien de partage — `GET /shares/links/:token`
* (route publique : le 401 n'a aucun sens ici, handling désactivé).
*/
suspend fun getShareLink(token: String): ShareLinkDto =
unwrap({ apiService.getShareLink(token) }, skipUnauthorizedHandling = true)
/**
* Grants actifs d'une ressource possédée — `GET /files/:id/shares`
* (owner uniquement, 404 sinon).
*/
suspend fun listShares(fileId: String): List<ShareGrantDto> =
unwrap({ apiService.listShares(fileId) })
/**
* Liens publics actifs d'une ressource possédée — `GET /files/:id/links`
* (owner uniquement, 404 sinon).
*/
suspend fun listLinks(fileId: String): List<ShareLinkDto> =
unwrap({ apiService.listLinks(fileId) })
/**
* Octets physiques d'un fichier visible — `GET /files/:id/content`
* (binaire brut, hors enveloppe). Streaming sans cache : lecture bornée
* à [maxBytes] (+1 pour détecter le dépassement → `FILE_TOO_LARGE`),
* jamais persistée. 404 = invisible ou metadata-only sans octets.
*/
suspend fun downloadContentBytes(
fileId: String,
maxBytes: Long = MAX_CONTENT_BYTES,
): ByteArray {
val response = try {
apiService.downloadContent(fileId)
} catch (e: CancellationException) {
throw e
} catch (e: IOException) {
Timber.d(e, "api: transport error (content)")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} catch (e: Exception) {
if (e is CancellationException) throw e
Timber.d(e, "api: unexpected error (content)")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
}
if (!response.isSuccessful) {
val status = response.code()
if (status == 401) {
onUnauthorized?.invoke()
}
val error = response.errorBody()?.use { body ->
body.string().let { raw ->
runCatching { errorEnvelopeAdapter.fromJson(raw)?.error }.getOrNull()
}
}
throw ApiException(
code = error?.code ?: if (status == 404) "NOT_FOUND" else "HTTP_$status",
message = error?.message ?: "HTTP $status",
httpCode = status,
)
}
val body = response.body()
?: throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide (corps vide)", response.code())
if (body.contentLength() > maxBytes) {
body.close()
throw ApiException("FILE_TOO_LARGE", "Fichier trop volumineux pour le streaming", response.code())
}
try {
body.byteStream().use { input ->
val out = java.io.ByteArrayOutputStream()
val buf = ByteArray(32 * 1024)
var total = 0L
while (true) {
val read = input.read(buf)
if (read < 0) break
total += read
if (total > maxBytes) {
throw ApiException("FILE_TOO_LARGE", "Fichier trop volumineux pour le streaming", response.code())
}
out.write(buf, 0, read)
}
return out.toByteArray()
}
} catch (e: ApiException) {
throw e
} catch (e: CancellationException) {
throw e
} catch (e: IOException) {
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} finally {
body.close()
}
}
companion object {
/** Borne streaming sans cache : 12 Mo (jamais en RAM au-delà). */
const val MAX_CONTENT_BYTES = 12 * 1024 * 1024L
}
private suspend fun <T> unwrap( private suspend fun <T> unwrap(
call: suspend () -> Response<ApiEnvelope<T>>, call: suspend () -> Response<ApiEnvelope<T>>,
skipUnauthorizedHandling: Boolean = false, skipUnauthorizedHandling: Boolean = false,
): T { ): T = unwrapWithMeta(call, skipUnauthorizedHandling).first
private suspend fun <T> unwrapWithMeta(
call: suspend () -> Response<ApiEnvelope<T>>,
skipUnauthorizedHandling: Boolean = false,
): Pair<T, ApiMeta?> {
val response = try { val response = try {
call() call()
} catch (e: CancellationException) {
// Ne jamais avaler l'annulation : la convertir en ApiException
// corromprait les scopes et le WorkManager (M22).
throw e
} catch (e: JsonDataException) {
Timber.w(e, "api: corps inattendu (parsing)")
throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide", 0)
} catch (e: JsonEncodingException) {
Timber.w(e, "api: corps inencodable (parsing)")
throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide", 0)
} catch (e: IOException) { } catch (e: IOException) {
Timber.d(e, "api: transport error") Timber.d(e, "api: transport error")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0) throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} catch (e: Exception) { } catch (e: Exception) {
if (e is CancellationException) throw e
Timber.d(e, "api: unexpected error") Timber.d(e, "api: unexpected error")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0) throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} }
@@ -151,6 +309,6 @@ class ApiClient @Inject constructor(
httpCode = response.code(), httpCode = response.code(),
) )
} }
return data return data to envelope.meta
} }
} }
@@ -1,28 +1,36 @@
package com.kazier.mobile.data.remote package com.kazier.mobile.data.remote
import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
import com.kazier.mobile.data.remote.dto.FileDto import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.data.remote.dto.IdResultDto
import com.kazier.mobile.data.remote.dto.LoginRequestDto import com.kazier.mobile.data.remote.dto.LoginRequestDto
import com.kazier.mobile.data.remote.dto.LoginResponseDto import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.OcrJobDto import com.kazier.mobile.data.remote.dto.OcrJobDto
import com.kazier.mobile.data.remote.dto.OcrSubmitDto import com.kazier.mobile.data.remote.dto.OcrSubmitDto
import com.kazier.mobile.data.remote.dto.ResolvedUserDto import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.ShareGrantDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult import com.kazier.mobile.data.remote.dto.SyncOpsResult
import okhttp3.MultipartBody import okhttp3.MultipartBody
import okhttp3.RequestBody import okhttp3.RequestBody
import okhttp3.ResponseBody
import retrofit2.Response import retrofit2.Response
import retrofit2.http.Body import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET import retrofit2.http.GET
import retrofit2.http.Multipart import retrofit2.http.Multipart
import retrofit2.http.PATCH
import retrofit2.http.POST import retrofit2.http.POST
import retrofit2.http.Part import retrofit2.http.Part
import retrofit2.http.Path import retrofit2.http.Path
import retrofit2.http.Query import retrofit2.http.Query
import retrofit2.http.Streaming
/** /**
* Contrat HTTP V1 — copie de `mobile/api/client.ts` (le client mobile est la * Contrat HTTP V1 — copie de `mobile/api/client.ts` (le client mobile est la
@@ -107,4 +115,76 @@ interface ApiService {
suspend fun getFileOcr( suspend fun getFileOcr(
@Path("id") fileId: String, @Path("id") fileId: String,
): Response<ApiEnvelope<FileOcrDto>> ): Response<ApiEnvelope<FileOcrDto>>
/** Détail d'un fichier visible (own ou shared) — `GET /files/:id`. */
@GET("files/{id}")
suspend fun getFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<FileDto>>
/**
* Octets physiques d'un fichier visible (viewer+, own ou shared) —
* `GET /files/:id/content` (binaire brut, hors enveloppe `{data}`).
* Streaming lecture seule : le client ne persiste rien (V1 streaming).
* 404 = invisible OU metadata-only jamais uploadé (indistinguables).
*/
@Streaming
@GET("files/{id}/content")
suspend fun downloadContent(
@Path("id") fileId: String,
): Response<ResponseBody>
/** Suppression serveur d'un fichier possédé — `DELETE /files/:id`. */
@DELETE("files/{id}")
suspend fun deleteFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<IdResultDto>>
/**
* Recherche serveur (`GET /files/search?q=…`, paginé `meta`). Non consommée
* en V1 (recherche 100 % locale via Room) — exposée pour parité contrat.
*/
@GET("files/search")
suspend fun searchFiles(
@Query("q") query: String,
@Query("page") page: Int?,
@Query("pageSize") pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>>
/**
* Rotation du mot de passe du compte connecté (`PATCH /users/me/password`,
* `current_password` requis). Limite V1 : les tokens déjà émis restent
* valides jusqu'à expiration (7 j, pas de révocation).
*/
@PATCH("users/me/password")
suspend fun changePassword(
@Body body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>>
/**
* Résolution anonyme d'un lien de partage (`GET /shares/links/:token`,
* route publique — jamais de `Bearer`, cf. `AuthInterceptor`).
*/
@GET("shares/links/{token}")
suspend fun getShareLink(
@Path("token") token: String,
): Response<ApiEnvelope<ShareLinkDto>>
/**
* Grants actifs d'une ressource possédée (`GET /files/:id/shares`,
* owner uniquement — 404 sinon, pas d'énumération).
*/
@GET("files/{id}/shares")
suspend fun listShares(
@Path("id") fileId: String,
): Response<ApiEnvelope<List<ShareGrantDto>>>
/**
* Liens publics actifs d'une ressource possédée (`GET /files/:id/links`,
* owner uniquement — même forme que `getShareLink`).
*/
@GET("files/{id}/links")
suspend fun listLinks(
@Path("id") fileId: String,
): Response<ApiEnvelope<List<ShareLinkDto>>>
} }
@@ -7,9 +7,12 @@ import javax.inject.Singleton
import com.kazier.mobile.auth.TokenProvider import com.kazier.mobile.auth.TokenProvider
/** /**
* Injecte `Authorization: Bearer <token>` sur chaque requête si un token est * Injecte `Authorization: Bearer <token>` sur chaque requête protégée si un
* disponible. Sans token (mode local / non connecté), aucune entête n'est posée * token est disponible. Les routes publiques (`POST /devices`,
* — le serveur répondra 401, géré proprement par `ApiClient`. * `POST /auth/login`, `GET /shares/links/:token`, `/health`) ne reçoivent
* jamais de `Bearer` (hygiène + pas d'amplification de fuite, cf. M26/m26).
* Sans token (mode local / non connecté), aucune entête n'est posée — le
* serveur répondra 401, géré proprement par `ApiClient`.
*/ */
@Singleton @Singleton
class AuthInterceptor @Inject constructor( class AuthInterceptor @Inject constructor(
@@ -17,11 +20,31 @@ class AuthInterceptor @Inject constructor(
) : Interceptor { ) : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response { override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request()
val requestBuilder = request.newBuilder()
val token = tokenProvider.current val token = tokenProvider.current
val requestBuilder = chain.request().newBuilder() if (token != null && !isPublic(request.url.encodedPath)) {
if (token != null) {
requestBuilder.header("Authorization", "Bearer $token") requestBuilder.header("Authorization", "Bearer $token")
} }
return chain.proceed(requestBuilder.build()) return chain.proceed(requestBuilder.build())
} }
companion object {
/**
* Segments terminaux des routes publiques V1 (après réécriture par
* `ServerUrlInterceptor`, la base inclut `/api/v1` — on matche en
* suffixe pour rester indépendant du préfixe configuré).
*/
private val PUBLIC_SUFFIXES = listOf(
"/devices",
"/auth/login",
"/health",
)
fun isPublic(encodedPath: String): Boolean {
if (PUBLIC_SUFFIXES.any { encodedPath.endsWith(it) }) return true
// Lien de partage anonyme : /api/v1/shares/links/:token.
return encodedPath.contains("/shares/links/")
}
}
} }
@@ -3,6 +3,7 @@ package com.kazier.mobile.data.remote
import com.kazier.mobile.domain.ServerConfigStore import com.kazier.mobile.domain.ServerConfigStore
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
import kotlinx.coroutines.runBlocking
import okhttp3.HttpUrl.Companion.toHttpUrl import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.Interceptor import okhttp3.Interceptor
import okhttp3.Response import okhttp3.Response
@@ -13,6 +14,11 @@ import timber.log.Timber
* La base Retrofit n'est qu'un placeholder ; c'est cet interceptor qui décide * La base Retrofit n'est qu'un placeholder ; c'est cet interceptor qui décide
* du schéma/host/port réels, en préservant le préfixe de chemin de la base * du schéma/host/port réels, en préservant le préfixe de chemin de la base
* configurée (ex. `/api/v1`) ainsi que la query d'origine. * configurée (ex. `/api/v1`) ainsi que la query d'origine.
*
* Garde M26 : si le `load()` du cold start n'a pas encore restauré l'URL
* persistée, l'interceptor le fait lui-même (bloquant, thread OkHttp — jamais
* le Main) au lieu de laisser partir la requête vers l'hôte par défaut
* (avec le `Bearer` restauré — fuite).
*/ */
@Singleton @Singleton
class ServerUrlInterceptor @Inject constructor( class ServerUrlInterceptor @Inject constructor(
@@ -22,6 +28,10 @@ class ServerUrlInterceptor @Inject constructor(
override fun intercept(chain: Interceptor.Chain): Response { override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request() val request = chain.request()
if (!serverConfigStore.isLoaded) {
runBlocking { serverConfigStore.load() }
}
val targetUrl = runCatching { val targetUrl = runCatching {
(serverConfigStore.current.trimEnd('/') + "/").toHttpUrl() (serverConfigStore.current.trimEnd('/') + "/").toHttpUrl()
}.getOrNull() }.getOrNull()
@@ -32,8 +42,17 @@ class ServerUrlInterceptor @Inject constructor(
} }
val original = request.url val original = request.url
// La base Retrofit placeholder contient déjà le préfixe de chemin
// (`/api/v1`) : ne pas le dupliquer quand le chemin d'origine le porte.
val basePath = targetUrl.encodedPath.trimEnd('/')
val origPath = original.encodedPath
val mergedPath = if (basePath.isNotEmpty() && (origPath == basePath || origPath.startsWith("$basePath/"))) {
origPath
} else {
basePath + "/" + origPath.trimStart('/')
}
val rewritten = targetUrl.newBuilder() val rewritten = targetUrl.newBuilder()
.encodedPath(targetUrl.encodedPath.trimEnd('/') + "/" + original.encodedPath.trimStart('/')) .encodedPath(mergedPath)
.encodedQuery(original.encodedQuery) .encodedQuery(original.encodedQuery)
.build() .build()
@@ -88,6 +88,45 @@ data class LoginResponseDto(
@Json(name = "user") val user: UserDto, @Json(name = "user") val user: UserDto,
) )
/** Requête `PATCH /users/me/password` — `{ current_password, new_password }`. */
data class ChangePasswordDto(
@Json(name = "current_password") val currentPassword: String,
@Json(name = "new_password") val newPassword: String,
)
/** Réponse `PATCH /users/me/password` et `DELETE /files/:id` — `{ id }`. */
data class IdResultDto(
@Json(name = "id") val id: String,
)
/**
* Réponse `GET /shares/links/:token` — métadonnées publiques du lien
* (jamais d'identité du propriétaire au-delà du contrat).
*/
data class ShareLinkDto(
@Json(name = "token") val token: String,
@Json(name = "resource_id") val resourceId: String,
@Json(name = "resourceType") val resourceType: String,
@Json(name = "name") val name: String,
@Json(name = "access") val access: String,
@Json(name = "expiresAt") val expiresAt: String? = null,
)
/**
* Grant actif `GET /files/:id/shares` (owner uniquement) — miroir de
* `ShareGrantDTO` Go. `expiresAt` en ms epoch (null = jamais), même
* convention que le snapshot `ResourcePermissionDto` pour les comparaisons
* locales (`System.currentTimeMillis()`).
*/
data class ShareGrantDto(
@Json(name = "granteeUserId") val granteeUserId: String,
@Json(name = "username") val username: String,
@Json(name = "access") val access: String,
@Json(name = "inherit") val inherit: Boolean,
@Json(name = "expiresAt") val expiresAt: Long? = null,
@Json(name = "updatedAt") val updatedAt: Long = 0L,
)
/** Outbox — une op du batch `POST /sync/ops` (docs/api-v1.md §6.1). */ /** Outbox — une op du batch `POST /sync/ops` (docs/api-v1.md §6.1). */
data class SyncOpDto( data class SyncOpDto(
@Json(name = "operation_id") val operationId: String, @Json(name = "operation_id") val operationId: String,
@@ -116,15 +155,19 @@ data class SyncFailedDto(
@Json(name = "message") val message: String, @Json(name = "message") val message: String,
) )
/** Snapshot `GET /sync/permissions` (docs/api-v1.md §6.2). */ /**
* Snapshot `GET /sync/permissions` (docs/api-v1.md §6.2, miroir de
* `ResourcePermission` Go : `sharedById *string`, `expiresAt *int64` ms epoch).
* M27 : typés (fini les `Any?` jamais lus) — lus par le cache et `canAccess`.
*/
data class ResourcePermissionDto( data class ResourcePermissionDto(
@Json(name = "resource_id") val resourceId: String, @Json(name = "resource_id") val resourceId: String,
@Json(name = "resourceType") val resourceType: String, @Json(name = "resourceType") val resourceType: String,
@Json(name = "effectiveAccess") val effectiveAccess: String, @Json(name = "effectiveAccess") val effectiveAccess: String,
@Json(name = "inherit") val inherit: Boolean, @Json(name = "inherit") val inherit: Boolean,
@Json(name = "ownerId") val ownerId: String? = null, @Json(name = "ownerId") val ownerId: String? = null,
@Json(name = "sharedById") val sharedById: Any? = null, @Json(name = "sharedById") val sharedById: String? = null,
@Json(name = "expiresAt") val expiresAt: Any? = null, @Json(name = "expiresAt") val expiresAt: Long? = null,
@Json(name = "cachedAt") val cachedAt: Long, @Json(name = "cachedAt") val cachedAt: Long,
@Json(name = "updatedAt") val updatedAt: Long, @Json(name = "updatedAt") val updatedAt: Long,
@Json(name = "name") val name: String = "", @Json(name = "name") val name: String = "",

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