36 Commits
Author SHA1 Message Date
venture a34220bf2d release 1.1.0 : sync V2 (upload, download, purge, placements, rétention, groupes)
Release / release-apk (push) Successful in 9m25s
Release / release-docker (push) Successful in 33s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m29s
CI / lint-mobile (push) Failing after 7m46s
CI / test-backend (push) Successful in 1m30s
CI / test-mobile (push) Successful in 9m27s
CI / build-backend (push) Successful in 47s
2026-09-25 20:27:14 +02:00
venture b28fcdc774 V2-5 : rétention auto (règle, worker quotidien, réglages stockage) 2026-09-25 19:56:21 +02:00
venture 88e89b9567 fix : 401 sans session ignoré (mode local non éjecté vers login) 2026-09-25 19:50:39 +02:00
venture a91ddf7aa8 V2-4 : placements multi-device (report_bytes, tables 000015, copies UI) 2026-09-25 19:45:33 +02:00
venture 0f90aad938 V2-2/V2-3 : download hors-ligne SAF + purge sûre (Room v18, DownloadWorker, release) 2026-09-25 19:27:08 +02:00
venture dd053a50c8 V2 : flag serveur has_content (migration 000014, lazy healing, FileDto) 2026-09-25 18:49:57 +02:00
venture c77af98a68 V2-1 : upload auto des octets (BytesUploadWorker, Room v17, SafMultipart) 2026-09-25 18:20:57 +02:00
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
257 changed files with 23011 additions and 2743 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
+22 -20
View File
@@ -2,7 +2,7 @@
## 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
@@ -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)
- `models/` — domain entities (users, devices, documents/resources, clients)
- `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`
- `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`)
- `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)
- `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, files/:id/placements, groups CRUD + membres** — 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, `OpenContent` (bytes streaming + lazy healing `has_content`), `ListShares`/`ListLinks` (owner-only), `SetHasContent` ; `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/UpsertGroup/Revoke, CreateLink/RevokeLink, ListActiveForResource, ListActiveLinksForResource, snapshot `ListEffectivePermissions` (grants user + groupe) ; `repository.Groups` : Create/ListForUser/AddMember/RemoveMember/Delete (V2-6, un niveau, sans imbrication) ; `repository.Placements` : EnsureLocation/Report/ListForResource (V2 multi-device) ; 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→000016) : `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`)
- `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/`
- Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }`
- 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`)
- 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/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/local/` — Room SQLite (DB `dot.db`, **version 18**, `Migrations.kt` : tables `folders`, `files` (+ `category`, `processed`, `content`, `ocr_text`, `ocr_attempts`, `ocr_queued_at`, `bytes_uploaded`, `bytes_upload_attempts`, `has_content_server`, `wanted_offline`), `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`) ; `SafMultipart.kt` (multipart SAF paresseux partagé upload OCR + V2)
- `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource`/`move_resource`/`delete_resource` + ops partage `share`/`update_share`/`revoke_share`/`create_link`/`revoke_link` + `report_bytes` V2 (`{ hasBytes }`, nouvel `operation_id` par état), é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é ; **upload V2** des octets après metadata synced, `bytes_uploaded` ; **download V2** vers SAF + rattachement, `wanted_offline`)
- `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`)
- `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`)
- `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), `FileDeleter.releaseLocalCopies` (purge sûre V2-3 : gate `isReleasable`, détachement cloud-only, zéro outbox)
- `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, **sauf `report_bytes` : dead-letter + suite du batch, jamais bloquant**) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) ; enchaîne `OcrAutoWorker` + `BytesUploadWorker` quand un fichier est promu (`DownloadWorker` sur demande hors-ligne) ; `RetentionWorker` (passe quotidienne, purge sûre des copies anciennes selon `RetentionStore`, sans réseau)
- `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`
- `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`
- `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex)
- `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 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 + stockage/retention), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien + copies V2 + groupes V2-6 ; `OpenLinkScreen` + deep-link `kazier://share/<token>`), `components`, `theme`
- `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `RetentionStore` (`all` | `last_months:N`), `GenerateId` (identifiants 32-hex)
- `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)
- 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
- 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.
- 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.
- 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)
- **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).
- **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`.
- **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.)
- **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) ; `report_bytes` (`{ hasBytes }`, V2 placements, nouvel `operation_id` par état) ; `share`/`update_share` acceptent `granteeUserId` XOR `granteeGroupId` (V2-6) — 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). 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)
@@ -92,7 +94,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- On-device OCR
- Full multi-tenant federation / public discovery
- 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
+22 -2
View File
@@ -5,10 +5,27 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
## [Unreleased]
### 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é.
## [1.1.0] - 2026-09-25
### Ajouté
- Upload V2 des octets : worker `BytesUploadWorker` (fichier par fichier, overwrite ciblée idempotente, cap 3 échecs, backoff), marqueurs `bytes_uploaded`/`bytes_upload_attempts` (Room v17, migration 16→17), multipart SAF mutualisé (`SafMultipart.kt`).
- Flag serveur `has_content` (migration `000014`, lazy healing : TRUE à l'upload / au `OpenContent` réussi, FALSE si octets disparus), exposé en `FileDto.hasContent` + miroir Room `has_content_server` (v18).
- Download V2 hors-ligne : `DownloadWorker` (fichier par fichier, écriture SAF dossier propre sinon racine, rattachement même `resource_id`, walk convergent par URI), marqueurs `has_content_server`/`wanted_offline` (Room v18, migration 17→18), bouton « Rendre disponible hors-ligne » dans le viewer distant.
- Purge sûre V2-3 « libérer de l'espace » : gate `isReleasable` (copie serveur connue), détachement cloud-only sans op outbox, bouton viewer + action multi-sélection.
- Placements multi-device : tables `storage_locations` + `resource_placements` (migration `000015`), op outbox `report_bytes` (viewer+, nouvel `operation_id` par état, dead-letter sans bloquer la file), `GET /files/:id/placements` (owner-only), reporting auto (upload/download/release/delete locale), section copies dans le sheet de partage.
- Rétention auto : règle `all` | `last_months:N` (`RetentionStore`), passe quotidienne `RetentionWorker` (purge sûre, sans réseau), réglages stockage (stats récupérables + libération manuelle).
- Groupes V2-6 (backend) : tables `groups` + `group_members` (migration `000016`, un niveau), CRUD + membres (owner-only), partage vers groupe via outbox (`granteeGroupId`, snapshot + enforcement étendus), `GROUP_NOT_FOUND`, lecture grants avec `granteeKind`.
- Groupes V2-6 (mobile) : section groupes du sheet (création, membres, suppression, partage au groupe), badge groupe sur les grants, endpoints CRUD + membres.
### Corrigé
- 401 sans session (mode local / jamais connecté) : ignoré sans purge ni événement — un appel égaré n'éjecte plus vers le login.
## [1.0.0] - 2026-09-25
### Ajouté
- Streaming lecture des fichiers distants : `GET /files/:id/content` (binaire brut, `Range`, viewer+), viewer mobile à la demande sans persistance (image/texte/PDF multi-pages, autres types non supportés).
- Gestion du partage côté owner : `GET /files/:id/shares` + `GET /files/:id/links`, sheet mobile (grants modifiables/révocables, liens création/copie/révocation, ouverture de lien, badge pending outbox), deep-link `kazier://share/<token>` + écran de résolution.
- Re-login silencieux : identifiants chiffrés persistés, renouvellement auto sur 401 (single-flight, file conservée si même compte), écran login avec avis d'expiration + username pré-rempli.
- Pipeline de release CI (GitLab) : lint, tests backend/mobile, build Docker, signature APK release, publication GitLab Release + Docker Hub.
- `backend/Dockerfile` multi-stage : image de production avec Tesseract (fra+eng) embarqué, user non-root, labels OCI.
- Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé).
@@ -17,6 +34,9 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
- Licence AGPLv3, badge README, `CHANGELOG.md`.
- Versioning Android aligné sur le `VERSION` racine (versionCode dérivé).
### Changé
- **Renommage : VaultDrop → Kazier.** Marque, package Android (`com.kazier.mobile`), module Go (`github.com/kazier/backend`), binaire/image `kazier-server`, creds Postgres par défaut. Le code interne `dot.db` est conservé.
### Corrigé
- Docs : en-tête `docs/api-v1.md` (référence à l'ancien client Expo remplacée par le client Kotlin), quickstart et docker de la doc Starlight.
- `.gitignore` racine (uploads, binaires, keystore, artifacts).
+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 |
| 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 |
| 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) |
+1 -1
View File
@@ -1 +1 @@
0.1.0
1.1.0
+2 -1
View File
@@ -8,7 +8,8 @@ MAX_FILE_SIZE_MB=50
OCR_LANG=fra+eng
# Sécurité — à changer en production (jamais commité)
AUTH_SECRET=dev-secret-change-me
# ≥ 32 caractères, ex. `openssl rand -hex 32`. Doit matcher config.go (min 32).
AUTH_SECRET=dev-secret-change-me-please-set-in-prod
# Premier admin (créé UNIQUEMENT si la table users est vide). Obligatoires au
# premier démarrage ; ignorés ensuite (l'env n'écrase jamais un compte).
+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.version="${VERSION}" \
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.created="${BUILD_DATE}" \
org.opencontainers.image.revision=""
+44 -5
View File
@@ -8,6 +8,7 @@ import (
"net/http"
"os"
"os/signal"
"sync"
"syscall"
"time"
@@ -41,14 +42,19 @@ func main() {
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)
if err != nil {
log.Fatalf("connexion postgres: %v", err)
}
if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil {
log.Fatalf("migrations postgres: %v", err)
}
defer conn.Close()
authManager, err := auth.NewManager(cfg.AuthSecret)
if err != nil {
@@ -59,9 +65,20 @@ func main() {
repo := repository.NewRepository(conn)
// 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 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(
repo,
@@ -74,7 +91,15 @@ func main() {
defer stop()
// 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)
srv := &http.Server{
@@ -95,5 +120,19 @@ func main() {
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("shutdown: %v", err)
}
// Le worker OCR dispose du même budget de 5s : on attend la fin du job en
// cours, passé ce délai le process sort (job resté `processing` → requeue
// au prochain boot via ResetStaleProcessing, jamais de job perdu).
ocrDone := make(chan struct{})
go func() {
ocrWg.Wait()
close(ocrDone)
}()
select {
case <-ocrDone:
log.Println("worker OCR arrêté")
case <-shutdownCtx.Done():
log.Println("worker OCR: budget 5s écoulé, arrêt forcé (jobs `processing` requeues au prochain boot)")
}
log.Println("arrêt propre")
}
+32 -3
View File
@@ -13,16 +13,27 @@ var expectedRoutes = []string{
"GET /api/v1/shares/links/:token",
"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/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",
"GET /api/v1/files/:id/placements",
"DELETE /api/v1/files/:id",
"POST /api/v1/files/upload",
"GET /api/v1/users/resolve",
"PATCH /api/v1/users/me/password",
"POST /api/v1/groups",
"GET /api/v1/groups",
"POST /api/v1/groups/:id/members",
"GET /api/v1/groups/:id/members",
"DELETE /api/v1/groups/:id/members/:userId",
"DELETE /api/v1/groups/:id",
"POST /api/v1/ocr/jobs",
"GET /api/v1/ocr/jobs/:id",
@@ -44,3 +55,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
import (
"fmt"
"os"
"strconv"
"strings"
"github.com/joho/godotenv"
)
@@ -19,6 +21,21 @@ type ApplicationConfig struct {
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) {
// .env optionnel — les défauts suffisent pour le dev local.
@@ -28,16 +45,33 @@ func LoadApplicationConfig() (*ApplicationConfig, error) {
if err != nil {
return nil, err
}
if port < 1 || port > 65535 {
return nil, fmt.Errorf("PORT hors plage 1-65535: %d", port)
}
maxSize, err := getInt("MAX_FILE_SIZE_MB", 50)
if err != nil {
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)
if err != nil {
return nil, err
}
if ocrWorkers < 1 || ocrWorkers > 16 {
return nil, fmt.Errorf("OCR_WORKERS hors plage 1-16: %d", ocrWorkers)
}
authSecret := get("AUTH_SECRET", defaultAuthSecret)
if isProduction() && (authSecret == "" || authSecret == defaultAuthSecret) {
return nil, fmt.Errorf("AUTH_SECRET doit être défini en production (pas de défaut)")
}
if len(authSecret) < minAuthSecretLen {
return nil, fmt.Errorf("AUTH_SECRET trop court (min %d caractères)", minAuthSecretLen)
}
return &ApplicationConfig{
Port: port,
@@ -46,13 +80,21 @@ func LoadApplicationConfig() (*ApplicationConfig, error) {
MaxFileSizeMB: int64(maxSize),
OcrLang: get("OCR_LANG", "fra+eng"),
OcrWorkers: ocrWorkers,
AuthSecret: get("AUTH_SECRET", "dev-secret-change-me"),
AuthSecret: authSecret,
AdminUsername: get("ADMIN_USERNAME", ""),
AdminPassword: get("ADMIN_PASSWORD", ""),
}, nil
}
func isProduction() bool {
env := strings.ToLower(strings.TrimSpace(os.Getenv("APP_ENV")))
if env == "" {
env = strings.ToLower(strings.TrimSpace(os.Getenv("ENV")))
}
return env == "production" || env == "prod"
}
func get(name string, defaultValue string) string {
value := os.Getenv(name)
if value == "" {
+41 -3
View File
@@ -10,6 +10,7 @@ func clearEnv(t *testing.T) {
for _, name := range []string{
"PORT", "DATABASE_URL", "UPLOAD_DIR", "MAX_FILE_SIZE_MB",
"OCR_LANG", "OCR_WORKERS", "AUTH_SECRET", "ADMIN_USERNAME", "ADMIN_PASSWORD",
"APP_ENV", "ENV",
} {
t.Setenv(name, "")
}
@@ -40,9 +41,12 @@ func TestLoadApplicationDefaults(t *testing.T) {
if cfg.OcrWorkers != 2 {
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)
}
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 != "" {
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("OCR_LANG", "eng")
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_PASSWORD", "toor")
@@ -65,12 +69,46 @@ func TestLoadApplicationEnvOverrides(t *testing.T) {
t.Fatalf("LoadApplicationConfig: %v", err)
}
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" {
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) {
clearEnv(t)
@@ -1,9 +1,21 @@
-- Reverse de 000007. Réversible SEULEMENT sur base vide (les ressources sont
-- détruites dans les deux sens : sans device associé, il n'y a rien à
-- préserver).
DELETE FROM resources;
-- Reverse de 000007. Chemin TESTS uniquement : ne jamais down en production
-- avec des données.
-- Les ressources retrouvent leur device d'origine via devices.user_id
-- (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 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
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é).
-- Destructif ASSUMÉ : à ce stade aucune release V1, la base de dev est RESET
-- (DELETE trivial sur une table vide ; PAS de user marqueur). Le modele
-- resources reste parfaitement identique par ailleurs.
DELETE FROM resources;
-- Migration DOUCE et non destructive (cf. #10) : AUCUNE suppression de
-- ressources (l'ancien DELETE FROM resources est supprimé).
-- Le device d'origine est résolu vers son dernier utilisateur connu
-- (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 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
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
-- 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
-- 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
ALTER COLUMN operation_id TYPE BIGINT USING operation_id::bigint;
ALTER TABLE operations ADD COLUMN operation_id_bigint 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}$');
@@ -0,0 +1 @@
ALTER TABLE resources DROP COLUMN IF EXISTS has_content;
@@ -0,0 +1,6 @@
-- V2 placements : `has_content` = « octets vus présents » (lazy healing).
-- TRUE à chaque upload (nouveau ou ciblé), healen FALSE→TRUE au premier
-- `OpenContent` réussi, TRUE→FALSE quand les octets ont disparu sous
-- UPLOAD_DIR. Les lignes existantes partent à FALSE (inconnu, pas absent) :
-- le premier accès les heal, aucun scan au boot.
ALTER TABLE resources ADD COLUMN has_content BOOLEAN NOT NULL DEFAULT FALSE;
@@ -0,0 +1,2 @@
DROP TABLE IF EXISTS resource_placements;
DROP TABLE IF EXISTS storage_locations;
@@ -0,0 +1,25 @@
-- V2 placements multi-device : où existent les octets d'une ressource.
-- `storage_locations` modélise chaque device (le serveur reste implicite via
-- `resources.has_content`, pas de ligne). `resource_placements` matérialise
-- les reports clients (`report_bytes` via l'outbox) : hint de présence,
-- jamais une preuve — le serveur ne vérifie pas les octets du device.
CREATE TABLE storage_locations (
id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'),
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
device_id TEXT NOT NULL UNIQUE CHECK (device_id ~ '^[0-9a-f]{32}$'),
type TEXT NOT NULL DEFAULT 'mobile' CHECK (type IN ('mobile', 'desktop', 'server')),
last_seen_at TIMESTAMPTZ DEFAULT NOW(),
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX idx_storage_locations_user ON storage_locations(user_id);
CREATE TABLE resource_placements (
resource_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE,
location_id TEXT NOT NULL REFERENCES storage_locations(id) ON DELETE CASCADE,
has_bytes BOOLEAN NOT NULL,
updated_at TIMESTAMPTZ DEFAULT NOW(),
PRIMARY KEY (resource_id, location_id)
);
CREATE INDEX idx_placements_location ON resource_placements(location_id);
@@ -0,0 +1,6 @@
DROP INDEX IF EXISTS idx_shares_active_group;
ALTER TABLE shares DROP CONSTRAINT IF EXISTS shares_grantee_xor_check;
ALTER TABLE shares ALTER COLUMN grantee_user_id SET NOT NULL;
ALTER TABLE shares DROP COLUMN IF EXISTS grantee_group_id;
DROP TABLE IF EXISTS group_members;
DROP TABLE IF EXISTS groups;
@@ -0,0 +1,32 @@
-- V2-6 groupes : partage vers un ensemble d'utilisateurs (famille, équipe).
-- `groups` : identité nommée possédée (created_by) ; `group_members` :
-- appartenances (pas de groupes imbriqués — un niveau, documenté).
-- `shares` accepte une cible groupe : exactement une des deux cibles est
-- renseignée (CHECK), avec un index d'unicité active par cible.
CREATE TABLE groups (
id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'),
name TEXT NOT NULL CHECK (name <> '' AND char_length(name) <= 255),
created_by TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE group_members (
group_id TEXT NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ DEFAULT NOW(),
PRIMARY KEY (group_id, user_id)
);
CREATE INDEX idx_group_members_user ON group_members(user_id);
ALTER TABLE shares ADD COLUMN grantee_group_id TEXT REFERENCES groups(id) ON DELETE CASCADE;
ALTER TABLE shares ALTER COLUMN grantee_user_id DROP NOT NULL;
ALTER TABLE shares
ADD CONSTRAINT shares_grantee_xor_check
CHECK (
(grantee_user_id IS NOT NULL AND grantee_group_id IS NULL)
OR (grantee_user_id IS NULL AND grantee_group_id IS NOT NULL)
);
CREATE UNIQUE INDEX idx_shares_active_group
ON shares(resource_id, grantee_group_id) WHERE revoked_at IS NULL AND grantee_group_id IS NOT NULL;
+104 -5
View File
@@ -2,20 +2,21 @@ package db
import (
"database/sql"
"os"
"fmt"
"net/url"
"strings"
"testing"
_ "github.com/lib/pq"
"github.com/lib/pq"
)
const defaultTestDatabaseURL = "postgres://kazier:kazier@localhost:5432/kazier_migrations_test?sslmode=disable"
func testDatabaseURL(t *testing.T) string {
t.Helper()
url := os.Getenv("TEST_DATABASE_URL")
if url == "" {
url = defaultTestDatabaseURL
url := TestDatabaseURL(defaultTestDatabaseURL)
if err := ensureTestDatabaseExists(url); err != nil {
t.Fatalf("ensure database: %v", err)
}
conn, err := sql.Open("postgres", url)
if err != nil {
@@ -28,6 +29,41 @@ func testDatabaseURL(t *testing.T) string {
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) {
t.Helper()
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")
}
// --- 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
var opType string
err = conn.QueryRow(`
@@ -270,6 +333,42 @@ func TestMigrationsUpDown(t *testing.T) {
t.Error("index unique partiel (id) WHERE revoked_at IS NULL manquant sur share_links")
}
// --- 000014 : has_content + 000015 : placements -------------------------
var hasContentCol int
err = conn.QueryRow(`
SELECT COUNT(*) FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'resources' AND column_name = 'has_content'`).Scan(&hasContentCol)
if err != nil {
t.Fatalf("has_content column: %v", err)
}
if hasContentCol == 0 {
t.Error("colonne resources.has_content manquante après 000014")
}
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "schema_migrations")
assertHexCheck(t, conn, "storage_locations", "id")
assertHexCheck(t, conn, "storage_locations", "device_id")
assertHexCheck(t, conn, "groups", "id")
// shares XOR : exactement une cible (user ou groupe).
var xorCheck int
err = conn.QueryRow(`
SELECT COUNT(*) FROM pg_constraint c
JOIN pg_class t ON t.oid = c.conrelid
WHERE t.relname = 'shares'
AND pg_get_constraintdef(c.oid) LIKE '%grantee_user_id%'
AND pg_get_constraintdef(c.oid) LIKE '%grantee_group_id%'`).Scan(&xorCheck)
if err != nil {
t.Fatalf("shares xor check: %v", err)
}
if xorCheck == 0 {
t.Error("CHECK XOR (grantee_user_id / grantee_group_id) manquant sur shares après 000016")
}
// --- 000016 : groupes + cible groupe sur shares -------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "schema_migrations")
if err := MigrateDownDatabase(url); err != nil {
t.Fatalf("migrate down: %v", err)
}
+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"
"fmt"
"net/url"
"os"
"strings"
"testing"
@@ -16,19 +15,16 @@ import (
// OpenTestDatabase ensures the test database exists, resets its schema, runs
// all migrations, and returns a live connection (closed via t.Cleanup).
// 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 {
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 == "" {
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
// ou non de la base cible)
+79 -8
View File
@@ -4,12 +4,12 @@ import (
"errors"
"net/http"
"strings"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/pkg/auth"
"github.com/kazier/backend/pkg/passwd"
"github.com/kazier/backend/repository"
"github.com/kazier/backend/service"
@@ -33,9 +33,55 @@ type LoginResponse struct {
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
// volontairement indistinguable entre « username inconnu » et « mauvais mot de
// passe » — même code, même message, délai égalisé via passwd.VerifyTimedEqual.
// volontairement indistinguable entre « username inconnu », « mauvais mot de
// 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) {
if Store == nil || Store.Repository == nil || Auth == nil {
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")
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)
user, userErr := Store.Repository.Users.GetByUsernameNormalized(normalized)
// 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 := ""
if userErr == nil && user != nil {
stored = user.PasswordHash
@@ -69,6 +127,12 @@ func AuthLogin(c *gin.Context) {
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not verify credentials")
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)
if err != nil {
@@ -76,24 +140,31 @@ func AuthLogin(c *gin.Context) {
return
}
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
}
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")
return
}
token, err := Auth.Issue(user.ID, req.DeviceID)
token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID)
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
}
api.OK(c, LoginResponse{
Token: token,
ExpiresAt: time.Now().Add(auth.TokenTTL).UnixMilli(),
ExpiresAt: expiresAt.UnixMilli(),
User: LoginUserDTO{
ID: user.ID,
Username: user.Username,
+70 -3
View File
@@ -42,6 +42,8 @@ func setTestStore(t *testing.T) *repository.Repository {
func setTestAuth(t *testing.T) {
t.Helper()
Auth, _ = auth.NewManager("test-secret")
ResetLoginRateLimit()
ResetDevicesRateLimit()
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) {
setTestAuth(t)
repo := setTestStore(t)
@@ -209,11 +276,11 @@ func TestAuthLoginUnregisteredDevice(t *testing.T) {
r := newTestRouterForAuth()
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())
}
if !strings.Contains(rec.Body.String(), "INVALID_DEVICE_ID") {
t.Errorf("code attendu INVALID_DEVICE_ID, got %s", rec.Body.String())
if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") {
t.Errorf("code attendu UNAUTHORIZED (anti-oracle), got %s", rec.Body.String())
}
}
+65 -1
View File
@@ -1,7 +1,10 @@
package handlers
import (
"net/http"
"regexp"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
@@ -9,12 +12,65 @@ import (
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 {
DeviceID string `json:"deviceId"`
}
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
if err := c.ShouldBindJSON(&req); err != nil || req.DeviceID == "" {
api.Error(c, 400, "INVALID_REQUEST", "missing deviceId")
@@ -25,6 +81,14 @@ func DevicesRegister(c *gin.Context) {
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 {
api.Error(c, 503, "SERVICE_UNAVAILABLE", "backend not initialized")
return
+81 -16
View File
@@ -8,17 +8,38 @@ import (
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/service"
)
func intParam(value string, fallback int) int {
if value == "" {
return fallback
// parsePageParams valide page/pageSize (400 si garbage, cf. FEEDBACK A7/A16)
// au lieu du fallback silencieux. Cap pageSize 200 et offset 100000.
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
}
parsed, err := strconv.Atoi(value)
if err != nil || parsed < 1 {
return fallback
page = p
}
return parsed
if v := c.Query("pageSize"); v != "" {
ps, err := strconv.Atoi(v)
if err != nil || ps < 1 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `pageSize`")
return 0, 0, false
}
pageSize = ps
}
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) {
@@ -27,12 +48,16 @@ func FilesList(c *gin.Context) {
return
}
userID := c.GetString(UserIDKey)
page := intParam(c.Query("page"), 1)
pageSize := intParam(c.Query("pageSize"), 50)
if pageSize > 200 {
pageSize = 200
page, pageSize, ok := parsePageParams(c)
if !ok {
return
}
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 {
writeError(c, err)
return
@@ -82,6 +107,33 @@ func FilesGetOcr(c *gin.Context) {
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) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -108,6 +160,10 @@ func FilesUpload(c *gin.Context) {
}
userID := c.GetString(UserIDKey)
folderID := c.PostForm("folderId")
if folderID != "" && !deviceIDPattern.MatchString(folderID) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `folderId`")
return
}
// resourceId optionnel : cible un fichier déjà connu (metadata-only de
// l'outbox) pour lui attacher ses octets physiques (ex. OCR serveur).
resourceID := c.PostForm("resourceId")
@@ -134,6 +190,12 @@ func FilesUpload(c *gin.Context) {
dto, err := Store.Upload(userID, file, folderID, resourceID)
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)
return
}
@@ -165,10 +227,13 @@ func FilesSearch(c *gin.Context) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "missing required query param `q`")
return
}
page := intParam(c.Query("page"), 1)
pageSize := intParam(c.Query("pageSize"), 50)
if pageSize > 200 {
pageSize = 200
if len(q) > 200 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `q` too long (max 200)")
return
}
page, pageSize, ok := parsePageParams(c)
if !ok {
return
}
files, total, err := Store.SearchFiles(userID, q, page, pageSize)
if err != nil {
+337 -5
View File
@@ -7,6 +7,8 @@ import (
"mime/multipart"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"testing"
"github.com/gin-gonic/gin"
@@ -73,6 +75,7 @@ func setup(t *testing.T) (*gin.Engine, *service.Resources, *repository.Repositor
}
handlers.Auth = manager
handlers.Store = store
handlers.ResetDevicesRateLimit()
gin.SetMode(gin.TestMode)
r := gin.New()
@@ -517,12 +520,12 @@ func TestFilesPaginationDefaultsAndClamp(t *testing.T) {
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, "")
env = expectOK(t, rec, "invalid-params")
if env.Meta == nil || env.Meta.Page != 1 || env.Meta.PageSize != 50 {
t.Errorf("defauts page/pageSize: %+v", env.Meta)
}
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "negative-params")
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)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?sort=zzz&order=up&pageSize=10", token, nil, "")
@@ -633,3 +636,332 @@ func TestFilesGetOcrOwnerShareAndScoping(t *testing.T) {
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/ocr", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "ocr-invalid-id")
}
func TestFilesUploadRejectsBadFilename(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "bn"), "badname-test-password", device)
// Body multipart construit à la main : filename brut, NON neutralisé par
// le writer stdlib (qui basename/encode de son côté). Le serveur doit
// rejeter en 400, jamais 500 (cf. A16).
rawUpload := func(filename string) *httptest.ResponseRecorder {
t.Helper()
boundary := "testboundary123"
body := "--" + boundary + "\r\n" +
"Content-Disposition: form-data; name=\"file\"; filename=\"" + filename + "\"\r\n" +
"Content-Type: application/octet-stream\r\n\r\n" +
"hi\r\n" +
"--" + boundary + "--\r\n"
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/files/upload", token, []byte(body), "multipart/form-data; boundary="+boundary)
return rec
}
rec := rawUpload("../../evil.txt")
// La stdlib Go basename déjà côté lecture (défense en profondeur côté
// service via sanitizeFileName, testé en unitaire + backslash) : le nom
// stocké est "evil.txt" et aucun chemin ne s'échappe (destPath dérivé
// uniquement de IDs 32-hex + extension sanitizée).
env := expectOK(t, rec, "upload-traversal-name")
var uploaded fileDTO
if err := json.Unmarshal(env.Data, &uploaded); err != nil {
t.Fatalf("upload-traversal-name: unmarshal: %v", err)
}
if uploaded.Name != "evil.txt" {
t.Errorf("nom traversal neutralisé attendu \"evil.txt\", got %q", uploaded.Name)
}
// Backslash : préservé par la stdlib → rejet service 400, jamais 500.
rec = rawUpload(`bad\name.txt`)
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "upload-backslash-name")
}
func TestSearchQTooLong(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ql"), "search-test-password", device)
long := make([]byte, 201)
for i := range long {
long[i] = 'a'
}
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-q-too-long")
}
func TestFilesContentStreaming(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "ct"), "content-test-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "cg"), "content-test-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "ch"), "content-test-password-c", outsiderDevice)
// Ressource metadata-only (outbox) puis upload ciblé des octets (≤10o, cf. setup).
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "note.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
rec := uploadMultipartToResource(t, r, ownerToken, fileID, "note.txt", []byte("hello"))
if rec.Code != http.StatusOK {
t.Fatalf("upload ciblé: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
// Owner : octets + Content-Type.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", ownerToken, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("content-owner: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
if rec.Body.String() != "hello" {
t.Errorf("content-owner = %q, attendu %q", rec.Body.String(), "hello")
}
if ct := rec.Header().Get("Content-Type"); ct == "" {
t.Errorf("content-owner: Content-Type manquant")
}
// Grantée viewer : mêmes octets (résolution dir owner, pas requester).
if err := repo.Shares.Upsert(fileID, grantee, "viewer", false, nil, owner); err != nil {
t.Fatalf("share: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", granteeToken, nil, "")
if rec.Code != http.StatusOK || rec.Body.String() != "hello" {
t.Errorf("content-grantee: attendu 200 hello, got %d %q", rec.Code, rec.Body.String())
}
// Outsider : 404 (pas d'énumération).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-outsider")
// Metadata-only sans octets : 404 (jamais uploadé).
bareID := repository.NewID()
if err := repo.Resources.InsertFile(owner, bareID, "vide.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert bare: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+bareID+"/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-no-bytes")
// ID invalide → 404 ; sans token → 401.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-invalid-id")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", "", nil, "")
if rec.Code != http.StatusUnauthorized {
t.Errorf("content-sans-token: attendu 401, got %d", rec.Code)
}
}
func TestFilesHasContentLazy(t *testing.T) {
r, store, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "hc"), "hascontent-password", ownerDevice)
getHasContent := func(fileID, label string) bool {
t.Helper()
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, ownerToken, nil, "")
env := expectOK(t, rec, label)
var dto struct {
HasContent bool `json:"hasContent"`
}
if err := json.Unmarshal(env.Data, &dto); err != nil {
t.Fatalf("%s: unmarshal: %v", label, err)
}
return dto.HasContent
}
// Upload avec octets → TRUE ; metadata-only → FALSE.
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "note.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
if getHasContent(fileID, "hascontent-bare") {
t.Errorf("metadata-only : hasContent attendu false")
}
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())
}
if !getHasContent(fileID, "hascontent-uploaded") {
t.Errorf("après upload : hasContent attendu true")
}
// Suppression manuelle sous UPLOAD_DIR puis GET content → 404 + heal FALSE.
matches, _ := filepath.Glob(filepath.Join(store.UploadDir, owner, fileID+".*"))
if len(matches) == 0 {
t.Fatalf("fichier physique introuvable sous %s", store.UploadDir)
}
if err := os.Remove(matches[0]); err != nil {
t.Fatalf("remove physique: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "hascontent-missing-bytes")
if getHasContent(fileID, "hascontent-healed-down") {
t.Errorf("octets disparus : hasContent attendu false après heal")
}
// Octets replacés à la main sur une ligne FALSE → GET content 200 + heal TRUE.
bareID := repository.NewID()
if err := repo.Resources.InsertFile(owner, bareID, "manuel.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert bare: %v", err)
}
if err := os.MkdirAll(filepath.Join(store.UploadDir, owner), 0o700); err != nil {
t.Fatalf("mkdir: %v", err)
}
if err := os.WriteFile(filepath.Join(store.UploadDir, owner, bareID+".txt"), []byte("hi"), 0o600); err != nil {
t.Fatalf("write: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+bareID+"/content", ownerToken, nil, "")
if rec.Code != http.StatusOK || rec.Body.String() != "hi" {
t.Fatalf("content-heal-up: attendu 200 hi, got %d %q", rec.Code, rec.Body.String())
}
if !getHasContent(bareID, "hascontent-healed-up") {
t.Errorf("octets constatés : hasContent attendu true après heal")
}
}
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")
}
func TestFilesPlacementsListing(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "pl"), "placements-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "pg"), "placements-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "ph"), "placements-password-c", outsiderDevice)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "placed.txt", "", 4, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
// Sans report : seule l'entrée serveur (hasContent false, metadata-only).
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/placements", ownerToken, nil, "")
env := expectOK(t, rec, "placements-server-only")
var only []map[string]any
if err := json.Unmarshal(env.Data, &only); err != nil {
t.Fatalf("placements-server-only: unmarshal: %v", err)
}
if len(only) != 1 || only[0]["locationType"] != "server" || only[0]["hasBytes"] != false {
t.Errorf("placements-server-only = %v, attendu 1 entrée serveur false", only)
}
// Report via l'outbox (owner) : l'entrée device apparaît.
reportBody := fmt.Sprintf(
`{"operations":[{"operation_id":%q,"resource_id":%q,"resource_type":"file","operation":"report_bytes","payload":{"hasBytes":true}}]}`,
repository.NewID(), fileID,
)
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/sync/ops", ownerToken, []byte(reportBody), "application/json")
if rec.Code != http.StatusOK {
t.Fatalf("sync/ops report: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/placements", ownerToken, nil, "")
env = expectOK(t, rec, "placements-owner")
var entries []struct {
LocationType string `json:"locationType"`
DeviceID string `json:"deviceId"`
HasBytes bool `json:"hasBytes"`
}
if err := json.Unmarshal(env.Data, &entries); err != nil {
t.Fatalf("placements-owner: unmarshal: %v", err)
}
if len(entries) != 2 || entries[0].LocationType != "server" {
t.Fatalf("placements-owner = %+v, attendu serveur + 1 device", entries)
}
if entries[1].LocationType != "mobile" || !entries[1].HasBytes || entries[1].DeviceID != ownerDevice {
t.Errorf("placements-owner[1] = %+v, attendu device owner true", entries[1])
}
// Granté et outsider : 404 (owner-only, pas d'énumération).
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+"/placements", granteeToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "placements-grantee")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/placements", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "placements-outsider")
// ID invalide → 404.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/placements", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "placements-invalid-id")
}
+143
View File
@@ -0,0 +1,143 @@
package handlers
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/service"
)
// groupIDParam validates a 32-hex group id path param (404, never 400 —
// group ids are unguessable, no enumeration).
func groupIDParam(c *gin.Context, name string) (string, bool) {
id := c.Param(name)
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "group not found")
return "", false
}
return id, true
}
// GroupsCreate stores an owned group : POST /groups {name}.
func GroupsCreate(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
var body struct {
Name string `json:"name"`
}
if err := c.ShouldBindJSON(&body); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
return
}
dto, err := Store.CreateGroup(c.GetString(UserIDKey), body.Name)
if err != nil {
if errors.Is(err, service.ErrInvalidUpload) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid group name")
return
}
writeError(c, err)
return
}
api.OK(c, dto)
}
// GroupsList returns owned + joined groups : GET /groups.
func GroupsList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
dtos, err := Store.ListGroups(c.GetString(UserIDKey))
if err != nil {
writeError(c, err)
return
}
api.OK(c, dtos)
}
// GroupMembersAdd adds an existing user : POST /groups/:id/members {userId}.
func GroupMembersAdd(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
var body struct {
UserID string `json:"userId"`
}
if err := c.ShouldBindJSON(&body); err != nil || !deviceIDPattern.MatchString(body.UserID) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `userId`")
return
}
if err := Store.AddGroupMember(c.GetString(UserIDKey), groupID, body.UserID); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": groupID})
}
// GroupMembersRemove removes a membership :
// DELETE /groups/:id/members/:userId.
func GroupMembersRemove(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
memberID, ok := groupIDParam(c, "userId")
if !ok {
return
}
if err := Store.RemoveGroupMember(c.GetString(UserIDKey), groupID, memberID); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": groupID})
}
// GroupsDelete removes an owned group : DELETE /groups/:id.
func GroupsDelete(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
if err := Store.DeleteGroup(c.GetString(UserIDKey), groupID); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": groupID})
}
// GroupMembersList returns memberships of an owned group :
// GET /groups/:id/members.
func GroupMembersList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
members, err := Store.ListMembers(c.GetString(UserIDKey), groupID)
if err != nil {
writeError(c, err)
return
}
api.OK(c, members)
}
+108
View File
@@ -0,0 +1,108 @@
package handlers_test
import (
"encoding/json"
"fmt"
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// V2-6 : CRUD groupes + membres via HTTP, scoping owner, 404 sans énumération.
func TestGroupsHttpFlow(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, _ := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "go"), "groups-http-password", ownerDevice)
otherDevice := repository.NewID()
otherToken, _ := registerAndLogin(t, r, repo, testUserUsername(otherDevice, "gx"), "groups-http-password-b", otherDevice)
// Création (nom trimé).
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/groups", ownerToken, []byte(`{"name":" Famille "}`), "application/json")
env := expectOK(t, rec, "groups-create")
var created struct {
ID string `json:"id"`
Name string `json:"name"`
Role string `json:"role"`
}
if err := json.Unmarshal(env.Data, &created); err != nil {
t.Fatalf("groups-create: unmarshal: %v", err)
}
if created.Name != "Famille" || created.Role != "owner" {
t.Errorf("groups-create = %+v", created)
}
// Nom vide → 400.
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/groups", ownerToken, []byte(`{"name":" "}`), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "groups-create-blank")
// Liste owner (1, owner) ; tiers (0).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups", ownerToken, nil, "")
env = expectOK(t, rec, "groups-list-owner")
var listed []map[string]any
if err := json.Unmarshal(env.Data, &listed); err != nil {
t.Fatalf("groups-list: unmarshal: %v", err)
}
if len(listed) != 1 {
t.Errorf("groups-list-owner = %d, attendu 1", len(listed))
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups", otherToken, nil, "")
env = expectOK(t, rec, "groups-list-other")
listed = nil
if err := json.Unmarshal(env.Data, &listed); err != nil {
t.Fatalf("groups-list-other: unmarshal: %v", err)
}
if len(listed) != 0 {
t.Errorf("groups-list-other = %d, attendu 0", len(listed))
}
// Ajout membre : besoin d'un user existant — on le crée via un login.
memberDevice := repository.NewID()
_, memberID := registerAndLogin(t, r, repo, testUserUsername(memberDevice, "gm"), "groups-http-password-c", memberDevice)
rec, _ = doRequest(
t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", ownerToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json",
)
expectOK(t, rec, "groups-add-member")
// Liste membres (owner) : le membre ajouté ; tiers → 404.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups/"+created.ID+"/members", ownerToken, nil, "")
envMembers := expectOK(t, rec, "groups-list-members")
var members []map[string]any
if err := json.Unmarshal(envMembers.Data, &members); err != nil {
t.Fatalf("groups-list-members: unmarshal: %v", err)
}
if len(members) != 1 || members[0]["id"] != memberID {
t.Errorf("groups-list-members = %v, attendu 1 membre", members)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups/"+created.ID+"/members", otherToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-list-members-other")
// Non-owner → 404.
rec, _ = doRequest(
t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", otherToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json",
)
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-add-other")
// Membre inconnu → GRANTEE_NOT_FOUND.
rec, _ = doRequest(
t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", ownerToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, repository.NewID())), "application/json",
)
expectError(t, rec, http.StatusNotFound, "GRANTEE_NOT_FOUND", "groups-add-unknown")
// Groupe inconnu → 404 partout (pas d'énumération).
unknown := repository.NewID()
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/groups/"+unknown+"/members", ownerToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-add-unknown-group")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+unknown, ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-delete-unknown")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/not-hex", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-invalid-id")
// Retrait puis suppression.
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID+"/members/"+memberID, ownerToken, nil, "")
expectOK(t, rec, "groups-remove-member")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID, otherToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-delete-other")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID, ownerToken, nil, "")
expectOK(t, rec, "groups-delete")
}
+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 (
"errors"
"log"
"net/http"
"strings"
@@ -19,6 +20,15 @@ const (
// Auth issues/verifies device bearer tokens; set once at startup (cmd/server).
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)
// 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
@@ -26,7 +36,13 @@ var Auth *auth.Manager
func RequireAuth(c *gin.Context) {
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 == "" {
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(DeviceIDKey, identity.DeviceID)
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")
handlers.Auth = manager
handlers.Store = store
handlers.ResetDevicesRateLimit()
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
+16 -1
View File
@@ -25,16 +25,31 @@ func RegisterRoutes(r *gin.Engine) {
protected.Use(RequireAuth)
{
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/folders", FoldersList)
protected.GET("/files/:id", FilesGet)
protected.GET("/files/:id/ocr", FilesGetOcr)
protected.GET("/files/:id/content", FilesContent)
protected.GET("/files/:id/shares", SharesList)
protected.GET("/files/:id/links", LinksList)
protected.GET("/files/:id/placements", PlacementsList)
protected.DELETE("/files/:id", FilesDelete)
protected.GET("/files/folders", FoldersList)
protected.POST("/files/upload", FilesUpload)
protected.GET("/users/resolve", ResolveUser)
protected.PATCH("/users/me/password", ChangePassword)
protected.POST("/groups", GroupsCreate)
protected.GET("/groups", GroupsList)
protected.POST("/groups/:id/members", GroupMembersAdd)
protected.GET("/groups/:id/members", GroupMembersList)
protected.DELETE("/groups/:id/members/:userId", GroupMembersRemove)
protected.DELETE("/groups/:id", GroupsDelete)
protected.POST("/ocr/jobs", OcrJobsCreate)
protected.GET("/ocr/jobs/:id", OcrJobsGet)
+11 -1
View File
@@ -1,6 +1,7 @@
package handlers
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
@@ -18,9 +19,18 @@ func ShareLinkGet(c *gin.Context) {
return
}
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)
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")
return
}
+74
View File
@@ -0,0 +1,74 @@
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)
}
// PlacementsList exposes byte presence of a resource the caller OWNS
// (server entry + device reports, newest first) : GET /files/:id/placements.
// Owner-only (404 otherwise, no enumeration).
func PlacementsList(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
}
placements, err := Store.ListPlacements(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, placements)
}
+11 -1
View File
@@ -2,6 +2,7 @@ package handlers
import (
"errors"
"log"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
@@ -23,11 +24,20 @@ func writeError(c *gin.Context, err error) {
api.Error(c, 404, "NOT_FOUND", "resource not found")
case errors.Is(err, repository.ErrGranteeNotFound):
api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist")
case errors.Is(err, repository.ErrGroupNotFound):
api.Error(c, 404, "GROUP_NOT_FOUND", "the specified group does not exist")
case errors.Is(err, repository.ErrNameConflict):
api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here")
case errors.Is(err, service.ErrFileTooLarge):
api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size")
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 (
"net/http"
"strconv"
"github.com/gin-gonic/gin"
@@ -9,10 +10,37 @@ import (
"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 {
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) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -20,11 +48,16 @@ func SyncOpsPush(c *gin.Context) {
}
userID := c.GetString(UserIDKey)
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxSyncOpsBodyBytes)
var req syncOpsRequest
if err := c.ShouldBindJSON(&req); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
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)
if err != nil {
@@ -40,10 +73,10 @@ func SyncPermissionsGet(c *gin.Context) {
return
}
userID := c.GetString(UserIDKey)
after := c.Query("after")
var afterMs int64
if after != "" {
afterMs = int64(intParam(after, 0))
afterMs, ok := parseAfterMs(c.Query("after"))
if !ok {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `after` cursor, must be non-negative epoch-millis")
return
}
perms, err := Store.Snapshot(userID, afterMs)
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) {
r, _, repo := setup(t)
device := repository.NewID()
+85 -8
View File
@@ -4,13 +4,42 @@ import (
"bytes"
"context"
"errors"
"fmt"
"os/exec"
"path/filepath"
"strings"
"time"
"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.
// Images are OCR'd directly; PDFs have their text layer extracted first
// (scanned PDFs → empty text, no rendering pipeline in V1).
@@ -18,20 +47,55 @@ type TesseractEngine struct{}
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) {
ctx, cancel := context.WithTimeout(ctx, tesseractTimeout)
defer cancel()
if strings.ToLower(filepath.Ext(filePath)) == ".pdf" {
return extractPDFText(filePath)
return extractPDFText(ctx, filePath)
}
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) {
// 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)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
stdout := &cappedBuffer{limit: outputCap}
stderr := &cappedBuffer{limit: outputCap}
cmd.Stdout = stdout
cmd.Stderr = stderr
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) {
return "", ctx.Err()
}
@@ -41,24 +105,37 @@ func runTesseract(ctx context.Context, filePath, lang string) (string, error) {
}
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
}
func extractPDFText(filePath string) (string, error) {
func extractPDFText(ctx context.Context, filePath string) (string, error) {
f, r, err := pdf.Open(filePath)
if err != nil {
return "", errors.New("pdf: " + err.Error())
}
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
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)
if p.V.IsNull() {
continue
return "", fmt.Errorf("pdf: page %d nulle", i)
}
plain, err := p.GetPlainText(nil)
if err != nil {
continue
return "", fmt.Errorf("pdf: page %d illisible: %w", i, err)
}
builder.WriteString(plain)
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
import "github.com/gin-gonic/gin"
import (
"log"
"github.com/gin-gonic/gin"
)
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) {
// 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{
"error": gin.H{"code": code, "message": message},
})
+18 -4
View File
@@ -3,6 +3,7 @@ package auth
import (
"crypto/sha256"
"errors"
"regexp"
"time"
"aidanwoods.dev/go-paseto"
@@ -14,6 +15,8 @@ const TokenTTL = 7 * 24 * time.Hour
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)
// et le device (claim secondaire, porté mais NON autorisant seul).
type Identity struct {
@@ -39,29 +42,40 @@ func NewManager(secret string) (*Manager, error) {
// Issue émet un token lié à un utilisateur ET à un device.
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()
expiresAt := now.Add(TokenTTL)
token := paseto.NewToken()
token.SetIssuedAt(now)
token.SetNotBefore(now)
token.SetExpiration(now.Add(TokenTTL))
token.SetExpiration(expiresAt)
token.SetSubject(userID)
// v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable).
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).
// 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) {
parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil)
if err != nil {
return Identity{}, ErrInvalidToken
}
userID, err := parsed.GetSubject()
if err != nil || userID == "" {
if err != nil || !hex32Pattern.MatchString(userID) {
return Identity{}, ErrInvalidToken
}
deviceID, err := parsed.GetString("device_id")
if err != nil || deviceID == "" {
if err != nil || !hex32Pattern.MatchString(deviceID) {
return Identity{}, ErrInvalidToken
}
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) {
m, _ := NewManager("test-secret")
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)
}
}
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")
)
// dummyHash est un hash argon2id valide d'un mot de passe aléatoire fixe.
// Il sert d'égalisation de timing : quand le username est inconnu, on vérifie
// quand même contre ce hash pour que le délai de réponse soit identique à un
// « mauvais mot de passe ».
// dummyHash est un hash argon2id valide d'un mot de passe aléatoire généré
// au boot. Il sert d'égalisation de timing : quand le username est inconnu,
// on vérifie quand même contre ce hash pour que le délai de réponse soit
// identique à un « mauvais mot de passe ». Aléatoire par boot pour éviter
// toute préimage hardcodée (cf. FEEDBACK A1).
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 {
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 {
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])
if err != nil {
@@ -84,6 +101,9 @@ func Verify(password, stored string) error {
if err != nil {
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)))
if subtle.ConstantTimeCompare(got, want) != 1 {
+13 -1
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,
// 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 {
_, err := d.DB.Exec(
result, err := d.DB.Exec(
`UPDATE devices SET user_id = $2, last_seen_at = NOW() WHERE device_id = $1`,
deviceID, userID,
)
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
import (
"errors"
"testing"
"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)
}
}
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)
}
}
+185
View File
@@ -0,0 +1,185 @@
package repository
import (
"database/sql"
"errors"
)
// Group is a named set of users (V2-6) : sharing to a group grants every
// member. One level only (no nested groups). The creator owns the group
// (member management + deletion) ; membership confers no admin rights.
type Group struct {
ID string
Name string
CreatedBy string
}
// Groups implements group persistence.
type Groups struct {
DB *sql.DB
}
// Create stores a group owned by ownerID and returns its id.
func (g *Groups) Create(name, ownerID string) (string, error) {
id := NewID()
_, err := g.DB.Exec(
`INSERT INTO groups (id, name, created_by) VALUES ($1, $2, $3)`,
id, name, ownerID,
)
if err != nil {
return "", err
}
return id, nil
}
// Get returns a group by id. No-rows → ErrNotFound.
func (g *Groups) Get(groupID string) (Group, error) {
var group Group
err := g.DB.QueryRow(
`SELECT id, name, created_by FROM groups WHERE id = $1`,
groupID,
).Scan(&group.ID, &group.Name, &group.CreatedBy)
if errors.Is(err, sql.ErrNoRows) {
return Group{}, ErrNotFound
}
return group, err
}
// IsOwner reports whether userID created the group.
func (g *Groups) IsOwner(groupID, userID string) (bool, error) {
var n int
err := g.DB.QueryRow(
`SELECT COUNT(*) FROM groups WHERE id = $1 AND created_by = $2`,
groupID, userID,
).Scan(&n)
return n > 0, err
}
// IsMember reports group membership (owner excluded : ownership is separate).
func (g *Groups) IsMember(groupID, userID string) (bool, error) {
var n int
err := g.DB.QueryRow(
`SELECT COUNT(*) FROM group_members WHERE group_id = $1 AND user_id = $2`,
groupID, userID,
).Scan(&n)
return n > 0, err
}
// GroupWithRole is a group listing row (owned or joined).
type GroupWithRole struct {
Group
Role string // "owner" | "member"
}
// ListForUser returns groups the user owns or joins, owned first.
func (g *Groups) ListForUser(userID string) ([]GroupWithRole, error) {
rows, err := g.DB.Query(
`SELECT id, name, created_by,
CASE WHEN created_by = $1 THEN 'owner' ELSE 'member' END AS role
FROM groups
WHERE created_by = $1 OR id IN (SELECT group_id FROM group_members WHERE user_id = $1)
ORDER BY created_at ASC`,
userID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []GroupWithRole
for rows.Next() {
var gr GroupWithRole
if err := rows.Scan(&gr.ID, &gr.Name, &gr.CreatedBy, &gr.Role); err != nil {
return nil, err
}
out = append(out, gr)
}
return out, rows.Err()
}
// AddMember inserts a membership. Idempotent on replay (ON CONFLICT DO
// NOTHING) ; returns rows-affected style via ErrNotFound when the group or
// the user does not exist (FK violation mapped).
func (g *Groups) AddMember(groupID, userID string) error {
_, err := g.DB.Exec(
`INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
ON CONFLICT DO NOTHING`,
groupID, userID,
)
if isForeignKeyViolation(err) {
return ErrNotFound
}
return err
}
// RemoveMember deletes a membership. Missing row → ErrNotFound.
func (g *Groups) RemoveMember(groupID, userID string) error {
result, err := g.DB.Exec(
`DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`,
groupID, userID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// Member is a group membership row (owner view).
type Member struct {
UserID string
Username string
}
// ListMembers returns memberships of a group, ordered by username.
func (g *Groups) ListMembers(groupID string) ([]Member, error) {
rows, err := g.DB.Query(
`SELECT u.id, COALESCE(u.username, u.id)
FROM group_members gm
JOIN users u ON u.id = gm.user_id AND u.deleted_at IS NULL
WHERE gm.group_id = $1
ORDER BY COALESCE(u.username, u.id) ASC`,
groupID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Member
for rows.Next() {
var m Member
if err := rows.Scan(&m.UserID, &m.Username); err != nil {
return nil, err
}
out = append(out, m)
}
return out, rows.Err()
}
// Errors specific to groups.
var ErrGroupNotFound = errors.New("group not found")
// Delete removes a group (owner only — caller checks). Shares targeting it
// cascade (FK), placements are untouched (device-scoped, not group-scoped).
func (g *Groups) Delete(groupID, ownerID string) error {
result, err := g.DB.Exec(
`DELETE FROM groups WHERE id = $1 AND created_by = $2`,
groupID, ownerID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
+47 -8
View File
@@ -22,6 +22,12 @@ var ErrJobNotFound = errors.New("ocr job not found")
// ErrNoQueuedJobs marks an OCR queue drained (no job to claim).
var ErrNoQueuedJobs = errors.New("no queued ocr jobs")
// ErrJobStateConflict marks a guarded transition attempted from an
// unexpected state (double Complete, Fail of a non-processing job,
// TouchProcessing of a non-queued job). Terminal states are sticky:
// a second transition never overwrites the first.
var ErrJobStateConflict = errors.New("ocr job state conflict")
type OcrJobs struct{ DB *sql.DB }
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 {
_, err := o.DB.Exec(
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'processing', started_at = NOW()
WHERE job_id = $1 AND device_id = $2 AND status = 'queued'`,
jobID, deviceID,
)
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
@@ -96,12 +112,15 @@ func (o *OcrJobs) ClaimNext() (OcrJobRow, error) {
// ResetStaleProcessing requeues jobs stuck in `processing` (worker crash /
// 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) {
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'queued', started_at = NULL
WHERE status = 'processing' AND started_at < $1`,
time.Now().Add(-olderThan),
WHERE status = 'processing'
AND (started_at IS NULL OR started_at < NOW() - ($1::bigint * INTERVAL '1 millisecond'))`,
olderThan.Milliseconds(),
)
if err != nil {
return 0, err
@@ -110,19 +129,39 @@ func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, 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()
WHERE job_id = $1 AND device_id = $2`,
WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
jobID, deviceID, text,
)
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 {
_, 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()
WHERE job_id = $1 AND device_id = $2`,
WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
jobID, deviceID, message,
)
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 {
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 {
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) {
repo, _, deviceID, fileID := seedOcrJobFixture(t)
jobID := NewID()
@@ -179,3 +248,24 @@ func TestOcrJobsResetStaleProcessing(t *testing.T) {
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
import (
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"regexp"
@@ -16,9 +18,26 @@ type Operations struct {
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.
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.
func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
var exists int
@@ -32,20 +51,157 @@ func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
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).
// 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 {
if !operationIDPattern.MatchString(operationID) {
return ErrInvalidOperationID
}
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
return ErrInvalidPayload
}
var refTypeValue any
if refType != "" {
refTypeValue = refType
}
_, err := o.DB.Exec(
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload)
VALUES ($1, $2, $3, $4, $5, $6, $7)
`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, 'applied')
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
}
@@ -62,7 +218,9 @@ func jsonBytes(payload []byte) any {
return []byte(`{}`)
}
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
}
+120 -13
View File
@@ -1,7 +1,6 @@
package repository
import (
"encoding/json"
"errors"
"testing"
@@ -66,7 +65,7 @@ func TestOperationsRecordRejectsInvalidOperationID(t *testing.T) {
}
}
func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) {
func TestOperationsRecordRejectsInvalidPayload(t *testing.T) {
o, devices := newTestOperations(t)
deviceID := NewID()
if err := devices.Upsert(deviceID); err != nil {
@@ -74,20 +73,128 @@ func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) {
}
opID := NewID()
// Un payload non-JSON ne doit pas faire échouer la trace (jsonBytes → {}).
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err != nil {
t.Fatalf("record: %v", err)
// Un payload non-JSON est refusé (pas de normalisation silencieuse vers {}) :
// l'appelant (service) doit rejeter en amont en INVALID_REQUEST.
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
if err := o.DB.QueryRow(`SELECT payload::text FROM operations WHERE device_id = $1 AND operation_id = $2`, deviceID, opID).Scan(&stored); err != nil {
t.Fatalf("read payload: %v", err)
opID := NewID()
payload := []byte(`{"name":"x"}`)
// 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
if err := json.Unmarshal([]byte(stored), &parsed); err != nil {
t.Fatalf("payload stocké invalide: %q", stored)
// Ligne héritée sans payload_hash (pré-000013) : hash recalculé depuis
// le payload stocké → match quand identique.
stored.PayloadHash = ""
if err := stored.MatchesReplay("create_resource", resID, payload); err != nil {
t.Errorf("ligne héritée identique: %v", err)
}
if stored != "{}" {
t.Errorf("payload normalisé attendu {}, got %q", stored)
if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"z"}`)); !errors.Is(err, ErrPayloadMismatch) {
t.Errorf("ligne héritée mutée : attendu ErrPayloadMismatch, got %v", err)
}
}
+85
View File
@@ -0,0 +1,85 @@
package repository
import (
"database/sql"
"time"
)
// Placement is one device's reported byte presence on a resource.
type Placement struct {
LocationType string
DeviceID string
HasBytes bool
UpdatedAt time.Time
}
// Placements implements the V2 multi-device presence hints
// (`storage_locations` + `resource_placements`, cf. V2.md §3.4-3.5, réduit :
// pas de `status` pending, juste `has_bytes` + fraîcheur).
type Placements struct {
DB *sql.DB
}
// EnsureLocation returns the location id for (user, device), creating it on
// first report. `user_id` tracks the last reporter (a device may change
// accounts) ; rows of departed users stay but are filtered at read time by
// resource visibility.
func (p *Placements) EnsureLocation(userID, deviceID string) (string, error) {
var id string
err := p.DB.QueryRow(
`INSERT INTO storage_locations (id, user_id, device_id, type)
VALUES ($1, $2, $3, 'mobile')
ON CONFLICT (device_id) DO UPDATE SET user_id = EXCLUDED.user_id, last_seen_at = NOW()
RETURNING id`,
NewID(), userID, deviceID,
).Scan(&id)
if err != nil {
return "", err
}
return id, nil
}
// Report upserts a device's byte presence for a resource. Naturally
// idempotent (same state twice = no-op) ; the outbox replay guard (A9)
// requires a FRESH operation_id per state change, documented in api-v1.md.
func (p *Placements) Report(userID, deviceID, resourceID string, hasBytes bool) error {
locationID, err := p.EnsureLocation(userID, deviceID)
if err != nil {
return err
}
_, err = p.DB.Exec(
`INSERT INTO resource_placements (resource_id, location_id, has_bytes, updated_at)
VALUES ($1, $2, $3, NOW())
ON CONFLICT (resource_id, location_id)
DO UPDATE SET has_bytes = EXCLUDED.has_bytes, updated_at = NOW()`,
resourceID, locationID, hasBytes,
)
return err
}
// ListForResource returns all device placements of a resource, newest first.
// Server-side bytes (`resources.has_content`) are NOT a row — the caller
// prepends the implicit server entry.
func (p *Placements) ListForResource(resourceID string) ([]Placement, error) {
rows, err := p.DB.Query(
`SELECT sl.type, sl.device_id, rp.has_bytes, rp.updated_at
FROM resource_placements rp
JOIN storage_locations sl ON sl.id = rp.location_id
WHERE rp.resource_id = $1
ORDER BY rp.updated_at DESC`,
resourceID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Placement
for rows.Next() {
var pl Placement
if err := rows.Scan(&pl.LocationType, &pl.DeviceID, &pl.HasBytes, &pl.UpdatedAt); err != nil {
return nil, err
}
out = append(out, pl)
}
return out, rows.Err()
}
+4
View File
@@ -12,6 +12,8 @@ type Repository struct {
OcrJobs *OcrJobs
Users *Users
Shares *Shares
Placements *Placements
Groups *Groups
}
func NewRepository(conn *sql.DB) *Repository {
@@ -22,5 +24,7 @@ func NewRepository(conn *sql.DB) *Repository {
OcrJobs: &OcrJobs{DB: conn},
Users: &Users{DB: conn},
Shares: &Shares{DB: conn},
Placements: &Placements{DB: conn},
Groups: &Groups{DB: conn},
}
}
+150 -51
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}$),
// mirroring the mobile's lower(hex(randomblob(16))). Never a UUID.
// Panics on entropy failure (legacy) — prefer NewIDErr for new code.
func NewID() string {
buf := make([]byte, 16)
if _, err := rand.Read(buf); err != nil {
id, err := NewIDErr()
if err != nil {
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 {
@@ -33,6 +43,14 @@ func isUniqueViolation(err error) bool {
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 {
ID string
Name string
@@ -42,6 +60,7 @@ type FileRow struct {
CreatedAt time.Time
UpdatedAt time.Time
OcrText string
HasContent bool
}
type FolderRow struct {
@@ -94,7 +113,7 @@ const grantedCTE = `
sh.inherit, 0
FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id
WHERE sh.grantee_user_id = $1 AND sh.revoked_at IS NULL
WHERE ` + granteeMatch + ` AND sh.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL
),
@@ -108,42 +127,39 @@ const grantedCTE = `
AND r.deleted_at IS NULL AND g.depth < 100
)`
func (r *Resources) folderExists(ownerID, folderID string) (bool, error) {
var exists int
err := r.DB.QueryRow(
`SELECT 1 FROM resources
WHERE resource_id = $1 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL`,
folderID, ownerID,
).Scan(&exists)
if err == sql.ErrNoRows {
return false, nil
}
return err == nil, err
}
// insert persiste une ligne file/folder avec parent-check ATOMIQUE
// (single-statement INSERT...SELECT) : le dossier parent (quand non vide)
// doit exister, appartenir au même owner, être un folder non supprimé —
// sinon ErrNotFound. L'ancien SELECT-then-INSERT (TOCTOU : parent supprimé
// entre check et insert → FK 500) est remplacé ; une violation FK résiduelle
// (course) est mappée vers ErrNotFound, jamais 500.
func (r *Resources) insert(ownerID, id, name, parentResourceID, resourceType string, size int64, mimeType, extension *string) error {
if parentResourceID != "" {
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(
result, err := r.DB.Exec(
`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)`,
id, resourceType, name, parentID, ownerID, size, mimeType, extension,
SELECT $1, $2, $3, NULLIF($4, ''), $5, $6, $7, $8
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) {
return ErrNameConflict
}
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
@@ -157,11 +173,11 @@ func (r *Resources) InsertFolder(ownerID, id, name, parentResourceID string) err
return r.insert(ownerID, id, name, parentResourceID, "folder", 0, nil, nil)
}
const fileColumns = `resource_id, name, size_bytes, COALESCE(mime_type, ''), COALESCE(parent_id, ''), created_at, updated_at, COALESCE(ocr_text, '')`
const fileColumns = `resource_id, name, size_bytes, COALESCE(mime_type, ''), COALESCE(parent_id, ''), created_at, updated_at, COALESCE(ocr_text, ''), COALESCE(has_content, FALSE)`
func (r *Resources) scanFile(scan func(...any) error) (FileRow, error) {
var row FileRow
err := scan(&row.ID, &row.Name, &row.Size, &row.MimeType, &row.FolderID, &row.CreatedAt, &row.UpdatedAt, &row.OcrText)
err := scan(&row.ID, &row.Name, &row.Size, &row.MimeType, &row.FolderID, &row.CreatedAt, &row.UpdatedAt, &row.OcrText, &row.HasContent)
return row, err
}
@@ -270,6 +286,26 @@ func (r *Resources) GetResourceOwner(resourceID string) (string, error) {
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.
func (r *Resources) DeleteFile(ownerID, resourceID string) (string, error) {
result, err := r.DB.Exec(
@@ -369,26 +405,28 @@ func (r *Resources) GetFolder(ownerID, resourceID string) (FolderRow, error) {
return row, err
}
// MoveResource sets parent_id (root when parentResourceID empty). The target
// folder must exist and belong to the owner. Absent source is a no-op.
// MoveResource sets parent_id (root when parentResourceID empty) avec
// 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 {
if parentResourceID != "" {
if _, err := r.GetFolder(ownerID, parentResourceID); err != nil {
return err
}
}
var parentID any
if parentResourceID != "" {
parentID = parentResourceID
}
result, err := r.DB.Exec(
`UPDATE resources SET parent_id = $3, updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
resourceID, ownerID, parentID,
`UPDATE resources SET parent_id = NULLIF($3, ''), updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL
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) {
return ErrNameConflict
}
if err != nil && isForeignKeyViolation(err) {
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
}
if err != nil {
return err
}
@@ -402,7 +440,7 @@ func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) e
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 {
result, err := r.DB.Exec(
`UPDATE resources SET name = $3, updated_at = NOW()
@@ -425,8 +463,18 @@ func (r *Resources) UpdateName(ownerID, resourceID, name string) error {
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
// (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 {
result, err := r.DB.Exec(
`UPDATE resources SET name = $2, updated_at = NOW()
@@ -453,9 +501,10 @@ func (r *Resources) UpdateNameByID(resourceID, name string) error {
// (size_bytes / mime_type / extension) after a targeted re-upload — used so a
// resource created metadata-only (outbox create_resource) receives its bytes
// for server-side OCR. Absent / not owned → ErrNotFound. Never renames or moves.
// Des octets viennent d'arriver : `has_content` passe à TRUE (V2 lazy).
func (r *Resources) UpdatePhysical(ownerID, resourceID string, size int64, mimeType, extension *string) error {
result, err := r.DB.Exec(
`UPDATE resources SET size_bytes = $3, mime_type = $4, extension = $5, updated_at = NOW()
`UPDATE resources SET size_bytes = $3, mime_type = $4, extension = $5, has_content = TRUE, updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND type = 'file' AND deleted_at IS NULL`,
resourceID, ownerID, size, mimeType, extension,
)
@@ -472,6 +521,29 @@ func (r *Resources) UpdatePhysical(ownerID, resourceID string, size int64, mimeT
return nil
}
// SetHasContent flips the V2 `has_content` flag (lazy healing) : TRUE quand
// des octets sont constatés (upload, OpenContent réussi), FALSE quand ils ont
// disparu sous UPLOAD_DIR. Best-effort côté service (jamais d'erreur vers le
// client). Absent / not owned → ErrNotFound (ignoré par l'appelant).
func (r *Resources) SetHasContent(ownerID, resourceID string, has bool) error {
result, err := r.DB.Exec(
`UPDATE resources SET has_content = $3, updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND type = 'file' AND deleted_at IS NULL`,
resourceID, ownerID, has,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// UpdateOcrText writes the server-computed OCR extract onto the resource
// (owner-scoped, bumping updated_at so the change flows through the sync
// snapshot). The text is then readable by every device of the user AND by
@@ -519,8 +591,35 @@ func (r *Resources) ExistsOwner(ownerID, resourceID string) (bool, error) {
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
// 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 {
_, err := r.DB.Exec(
`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) {
repo := newTestResources(t)
owner := NewID()
+131 -11
View File
@@ -71,11 +71,19 @@ type ResourceAccess struct {
Inherit bool
}
// Shares implements share persistence for user-to-user grants.
// Shares implements share persistence for user-to-user AND user-to-group
// grants (V2-6). A grant targets exactly one principal (shares XOR CHECK) :
// `grantee_user_id` for a user, `grantee_group_id` for a group (every member
// inherits, one level, no nesting).
type Shares struct {
DB *sql.DB
}
// granteeMatch matches the grants visible to a user: direct user grants plus
// grants to any group they belong to. `$1` is always the user id in the
// enclosing query (snapshot, enforcement, visibility CTEs).
const granteeMatch = `(sh.grantee_user_id = $1 OR sh.grantee_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))`
// Upsert inserts or updates an active share. On conflict (active row for
// same resource + grantee) the access, inherit, and expires_at are updated.
func (s *Shares) Upsert(resourceID, granteeUserID, access string, inherit bool, expiresAt *time.Time, createdBy string) error {
@@ -96,12 +104,13 @@ func (s *Shares) Upsert(resourceID, granteeUserID, access string, inherit bool,
return err
}
// Revoke soft-revokes the active share between a resource and a grantee.
func (s *Shares) Revoke(resourceID, granteeUserID string) error {
// Revoke soft-revokes the active share between a resource and a grantee
// (user id or group id — ids are unguessable 32-hex, globally unique).
func (s *Shares) Revoke(resourceID, granteeID string) error {
result, err := s.DB.Exec(
`UPDATE shares SET revoked_at = NOW(), updated_at = NOW()
WHERE resource_id = $1 AND grantee_user_id = $2 AND revoked_at IS NULL`,
resourceID, granteeUserID,
WHERE resource_id = $1 AND (grantee_user_id = $2 OR grantee_group_id = $2) AND revoked_at IS NULL`,
resourceID, granteeID,
)
if err != nil {
return err
@@ -153,7 +162,7 @@ seeded(id, type, updated_at, parent_id, grant_rank, created_by, expires_at, gran
sh.created_by, sh.expires_at, sh.inherit, r.name, TRUE
FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id
WHERE sh.grantee_user_id = $1 AND sh.revoked_at IS NULL
WHERE `+granteeMatch+` AND sh.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL
),
@@ -263,7 +272,7 @@ direct AS (
SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END AS rank
FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id
WHERE sh.resource_id = $2 AND sh.grantee_user_id = $1
WHERE sh.resource_id = $2 AND `+granteeMatch+`
AND sh.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL
@@ -276,7 +285,7 @@ inherited(id, grant_rank, depth) AS (
SELECT r.parent_id,
COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END
FROM shares sh
WHERE sh.resource_id = r.parent_id AND sh.grantee_user_id = $1
WHERE sh.resource_id = r.parent_id AND `+granteeMatch+`
AND sh.revoked_at IS NULL AND sh.inherit
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0),
0
@@ -286,7 +295,7 @@ inherited(id, grant_rank, depth) AS (
SELECT r.parent_id,
COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END
FROM shares sh
WHERE sh.resource_id = ag.id AND sh.grantee_user_id = $1
WHERE sh.resource_id = ag.id AND `+granteeMatch+`
AND sh.revoked_at IS NULL AND sh.inherit
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0),
ag.depth + 1
@@ -327,17 +336,44 @@ func (s *Shares) ResourceExists(resourceID string) (bool, error) {
}
// 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 {
var expires any
if expiresAt != nil {
expires = *expiresAt
}
_, err := s.DB.Exec(
res, err := s.DB.Exec(
`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,
)
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
@@ -428,5 +464,89 @@ func (s *Shares) ListActiveLinksForResource(resourceID string) ([]LinkInfo, erro
return links, rows.Err()
}
// ShareGrant is one active grant on a resource (owner view). Exactly one of
// GranteeUserID / GranteeGroupID is set (mirrors the shares XOR CHECK).
type ShareGrant struct {
GranteeUserID string
GranteeGroupID string
Username string
Access string
Inherit bool
ExpiresAt *time.Time
UpdatedAt time.Time
}
// GrantKind returns "group" for group-targeted grants, "user" otherwise.
func (g ShareGrant) GrantKind() string {
if g.GranteeGroupID != "" {
return "group"
}
return "user"
}
// UpsertGroup inserts or updates an active group-targeted share. Same
// idempotent semantics as Upsert, keyed by (resource, group).
func (s *Shares) UpsertGroup(resourceID, groupID, access string, inherit bool, expiresAt *time.Time, createdBy string) error {
var expires any
if expiresAt != nil {
expires = *expiresAt
}
_, err := s.DB.Exec(
`INSERT INTO shares (id, resource_id, grantee_group_id, access, inherit, created_by, expires_at)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (resource_id, grantee_group_id) WHERE revoked_at IS NULL AND grantee_group_id IS NOT NULL
DO UPDATE SET access = EXCLUDED.access,
inherit = EXCLUDED.inherit,
expires_at = EXCLUDED.expires_at,
updated_at = NOW()`,
NewID(), resourceID, groupID, access, inherit, createdBy, expires,
)
return err
}
// 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, s.grantee_group_id,
COALESCE(u.username, gr.name, COALESCE(s.grantee_user_id, s.grantee_group_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
LEFT JOIN groups gr ON gr.id = s.grantee_group_id
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
granteeUser sql.NullString
granteeGrp sql.NullString
expiresAt sql.NullTime
)
if err := rows.Scan(&granteeUser, &granteeGrp, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil {
return nil, err
}
if granteeUser.Valid {
g.GranteeUserID = granteeUser.String
}
if granteeGrp.Valid {
g.GranteeGroupID = granteeGrp.String
}
if expiresAt.Valid {
g.ExpiresAt = &expiresAt.Time
}
grants = append(grants, g)
}
return grants, rows.Err()
}
// Errors specific to shares.
var ErrGranteeNotFound = errors.New("grantee user not found")
+40 -13
View File
@@ -20,11 +20,12 @@ type Users struct {
DB *sql.DB
}
// Count retourne le nombre d'utilisateurs (y compris supprimés) — sert au
// bootstrap admin au démarrage.
// Count retourne le nombre d'utilisateurs ACTIFS (deleted_at IS NULL) — sert
// 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) {
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
}
@@ -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.
func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmin bool) (string, error) {
id := NewID()
_, err := u.DB.Exec(
id, err := NewIDErr()
if err != nil {
return "", err
}
_, err = u.DB.Exec(
`INSERT INTO users (id, username, username_normalized, password_hash, is_admin, created_at)
VALUES ($1, $2, $3, $4, $5, NOW())`,
id, username, usernameNormalized, passwordHash, isAdmin,
@@ -82,24 +86,47 @@ func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmi
return id, nil
}
// UpdatePassword remplace le hash du compte. Les tokens déjà émis restent
// valides 7 jours : limite assumée V1 (pas de liste de révocation).
// UpdatePassword remplace le hash du compte actif. Compte absent ou
// 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 {
_, err := u.DB.Exec(
`UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1`,
result, err := u.DB.Exec(
`UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
id, newHash,
)
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
// middleware (GetByID filtre deleted_at).
// MarkDeleted soft-delete un compte actif : les tokens issus sont rejetés par
// 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 {
_, err := u.DB.Exec(
`UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1`,
result, err := u.DB.Exec(
`UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
id,
)
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) {
+22 -2
View File
@@ -64,6 +64,11 @@ func TestUsersUpdatePassword(t *testing.T) {
if err != nil || row.PasswordHash != "hash-2" {
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) {
@@ -82,7 +87,22 @@ func TestUsersMarkDeletedHidesAccount(t *testing.T) {
if _, err := u.GetByUsernameNormalized("carol"); !errors.Is(err, ErrNotFound) {
t.Errorf("get par username après suppression : attendu ErrNotFound, got %v", err)
}
if n, _ := u.Count(); n != 1 {
t.Errorf("count doit compter aussi les supprimés (bootstrap), got %d", n)
// Count ne compte que les ACTIFS : carol soft-deleted → 0 (#9+A10). Une
// 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
// 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 {
count, err := repo.Users.Count()
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) {
s := newServiceStore(t)
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
}
+114
View File
@@ -0,0 +1,114 @@
package service
import (
"errors"
"strings"
"github.com/kazier/backend/repository"
)
// GroupDTO serializes a group for GET /groups.
type GroupDTO struct {
ID string `json:"id"`
Name string `json:"name"`
Role string `json:"role"` // "owner" | "member"
}
// sanitizeGroupName trims + caps display names (same spirit as file names).
func sanitizeGroupName(name string) (string, error) {
n := strings.TrimSpace(name)
if n == "" || len(n) > 255 {
return "", ErrInvalidUpload
}
return n, nil
}
// CreateGroup stores a group owned by userID.
func (s *Resources) CreateGroup(userID, name string) (GroupDTO, error) {
clean, err := sanitizeGroupName(name)
if err != nil {
return GroupDTO{}, err
}
id, err := s.Repository.Groups.Create(clean, userID)
if err != nil {
return GroupDTO{}, err
}
return GroupDTO{ID: id, Name: clean, Role: "owner"}, nil
}
// ListGroups returns groups the user owns or joins.
func (s *Resources) ListGroups(userID string) ([]GroupDTO, error) {
groups, err := s.Repository.Groups.ListForUser(userID)
if err != nil {
return nil, err
}
out := make([]GroupDTO, 0, len(groups))
for _, gr := range groups {
out = append(out, GroupDTO{ID: gr.ID, Name: gr.Name, Role: gr.Role})
}
return out, nil
}
// AddGroupMember adds an existing active user to a group the caller owns.
// Unknown group (or not owned) → ErrNotFound (no enumeration) ; unknown
// member → ErrGranteeNotFound (same code as share recipients).
func (s *Resources) AddGroupMember(userID, groupID, memberID string) error {
owner, err := s.Repository.Groups.IsOwner(groupID, userID)
if err != nil {
return err
}
if !owner {
return repository.ErrNotFound
}
if _, err := s.Repository.Users.GetByID(memberID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
return s.Repository.Groups.AddMember(groupID, memberID)
}
// RemoveGroupMember removes a membership (group must be owned by caller).
// Missing membership → ErrNotFound (idempotent-safe callers treat as done).
func (s *Resources) RemoveGroupMember(userID, groupID, memberID string) error {
owner, err := s.Repository.Groups.IsOwner(groupID, userID)
if err != nil {
return err
}
if !owner {
return repository.ErrNotFound
}
return s.Repository.Groups.RemoveMember(groupID, memberID)
}
// MemberDTO serializes a membership for GET /groups/:id/members.
type MemberDTO struct {
ID string `json:"id"`
Username string `json:"username"`
}
// ListMembers returns memberships of a group the caller owns.
func (s *Resources) ListMembers(userID, groupID string) ([]MemberDTO, error) {
owner, err := s.Repository.Groups.IsOwner(groupID, userID)
if err != nil {
return nil, err
}
if !owner {
return nil, repository.ErrNotFound
}
members, err := s.Repository.Groups.ListMembers(groupID)
if err != nil {
return nil, err
}
out := make([]MemberDTO, 0, len(members))
for _, m := range members {
out = append(out, MemberDTO{ID: m.UserID, Username: m.Username})
}
return out, nil
}
// DeleteGroup removes an owned group (member shares cascade via FK).
func (s *Resources) DeleteGroup(userID, groupID string) error {
return s.Repository.Groups.Delete(groupID, userID)
}
+195
View File
@@ -0,0 +1,195 @@
package service
import (
"testing"
"github.com/kazier/backend/repository"
)
// V2-6 : partage vers un groupe — les membres voient la ressource
// (snapshot + enforcement), les non-membres non. Révocation et suppression
// du groupe convergent.
func TestGroupShareSnapshotAndEnforcement(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "grp-owner")
memberID := mustCreateUser(t, s.Repository, "grp-member")
outsiderID := mustCreateUser(t, s.Repository, "grp-outsider")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
groupID, err := s.Repository.Groups.Create("Famille", ownerID)
if err != nil {
t.Fatalf("create group: %v", err)
}
if err := s.Repository.Groups.AddMember(groupID, memberID); err != nil {
t.Fatalf("add member: %v", err)
}
fileID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "g.txt"}),
syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{
"granteeGroupId": groupID,
"access": "editor",
}),
}); err != nil {
t.Fatalf("create+share-group: %v", err)
}
// Snapshot membre : rang editor hérité du groupe.
perms, err := s.Snapshot(memberID, 0)
if err != nil {
t.Fatalf("Snapshot member: %v", err)
}
if len(perms) != 1 || perms[0].EffectiveAccess != "editor" {
t.Fatalf("snapshot membre = %+v, attendu 1 editor", perms)
}
// Enforcement : le membre lit (GET file), l'outsider non.
ra, err := s.Repository.Shares.EffectiveAccess(memberID, fileID)
if err != nil || !ra.Accessible || ra.EffectiveRank != repository.AccessEditor {
t.Errorf("EffectiveAccess membre = %+v err=%v, attendu editor", ra, err)
}
row, err := s.Repo.GetFileVisible(memberID, fileID)
if err != nil || row.ID != fileID {
t.Errorf("membre doit voir le fichier : %+v err=%v", row, err)
}
if _, err := s.Repo.GetFileVisible(outsiderID, fileID); err == nil {
t.Errorf("outsider ne doit pas voir le fichier")
}
// Owner listing : grant kind=group au nom du groupe.
grants, err := s.ListShares(ownerID, fileID)
if err != nil || len(grants) != 1 {
t.Fatalf("ListShares = %+v err=%v", grants, err)
}
if grants[0].GranteeKind != "group" || grants[0].GranteeUserID != groupID || grants[0].Username != "Famille" {
t.Errorf("grant groupe = %+v", grants[0])
}
// Retrait du membre → disparaît du snapshot au pull complet.
if err := s.Repository.Groups.RemoveMember(groupID, memberID); err != nil {
t.Fatalf("remove member: %v", err)
}
perms, err = s.Snapshot(memberID, 0)
if err != nil {
t.Fatalf("Snapshot après retrait: %v", err)
}
if len(perms) != 0 {
t.Errorf("snapshot après retrait = %+v, attendu vide", perms)
}
// Suppression du groupe → plus de partage (cascade FK).
member2 := mustCreateUser(t, s.Repository, "grp-member2")
if err := s.Repository.Groups.AddMember(groupID, member2); err != nil {
t.Fatalf("add member2: %v", err)
}
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{
"granteeGroupId": groupID,
"access": "viewer",
}),
}); err != nil {
t.Fatalf("re-share: %v", err)
}
if err := s.DeleteGroup(ownerID, groupID); err != nil {
t.Fatalf("delete group: %v", err)
}
perms, err = s.Snapshot(member2, 0)
if err != nil {
t.Fatalf("Snapshot après delete: %v", err)
}
if len(perms) != 0 {
t.Errorf("snapshot après delete groupe = %+v, attendu vide", perms)
}
}
func TestGroupShareValidation(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "grpval-owner")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "v.txt"}),
}); err != nil {
t.Fatalf("create: %v", err)
}
apply := func(payload map[string]any) (SyncResult, error) {
return s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpShare, "file", payload),
})
}
// Groupe inconnu → GROUP_NOT_FOUND.
denied, err := apply(map[string]any{"granteeGroupId": repository.NewID(), "access": "viewer"})
if err != nil || denied.Applied != 0 || denied.Failed == nil || denied.Failed.Code != "GROUP_NOT_FOUND" {
t.Errorf("groupe inconnu: attendu halt GROUP_NOT_FOUND, got %+v err=%v", denied, err)
}
// Deux cibles → INVALID_REQUEST.
both, err := apply(map[string]any{
"granteeUserId": ownerID, "granteeGroupId": repository.NewID(), "access": "viewer",
})
if err != nil || both.Applied != 0 || both.Failed == nil || both.Failed.Code != "INVALID_REQUEST" {
t.Errorf("deux cibles: attendu halt INVALID_REQUEST, got %+v err=%v", both, err)
}
// Aucune cible → INVALID_REQUEST.
none, err := apply(map[string]any{"access": "viewer"})
if err != nil || none.Applied != 0 || none.Failed == nil || none.Failed.Code != "INVALID_REQUEST" {
t.Errorf("sans cible: attendu halt INVALID_REQUEST, got %+v err=%v", none, err)
}
}
func TestGroupManagementScoping(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "gm-owner")
otherID := mustCreateUser(t, s.Repository, "gm-other")
memberID := mustCreateUser(t, s.Repository, "gm-member")
group, err := s.CreateGroup(ownerID, " Équipe ")
if err != nil {
t.Fatalf("create: %v", err)
}
if group.Name != "Équipe" || group.Role != "owner" {
t.Errorf("groupe = %+v (nom trimé attendu)", group)
}
if _, err := s.CreateGroup(ownerID, " "); err == nil {
t.Errorf("nom vide attendu rejeté")
}
// Non-owner ne peut ni ajouter ni supprimer.
if err := s.AddGroupMember(otherID, group.ID, memberID); err == nil {
t.Errorf("add par non-owner attendu refusé")
}
if err := s.AddGroupMember(ownerID, group.ID, memberID); err != nil {
t.Fatalf("add: %v", err)
}
// Membre inexistant → GRANTEE_NOT_FOUND.
if err := s.AddGroupMember(ownerID, group.ID, repository.NewID()); err != repository.ErrGranteeNotFound {
t.Errorf("membre inconnu: attendu ErrGranteeNotFound, got %v", err)
}
if err := s.RemoveGroupMember(otherID, group.ID, memberID); err == nil {
t.Errorf("remove par non-owner attendu refusé")
}
// Listes : owner voit (owner), membre voit (member), tiers ne voit rien.
owned, _ := s.ListGroups(ownerID)
if len(owned) != 1 || owned[0].Role != "owner" {
t.Errorf("list owner = %+v", owned)
}
joined, _ := s.ListGroups(memberID)
if len(joined) != 1 || joined[0].Role != "member" {
t.Errorf("list member = %+v", joined)
}
none, _ := s.ListGroups(otherID)
if len(none) != 0 {
t.Errorf("list tiers = %+v, attendu vide", none)
}
if err := s.DeleteGroup(otherID, group.ID); err == nil {
t.Errorf("delete par non-owner attendu refusé")
}
if err := s.DeleteGroup(ownerID, group.ID); err != nil {
t.Fatalf("delete: %v", err)
}
}
-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 (
"context"
"errors"
"fmt"
"log"
"os"
"path/filepath"
"regexp"
"strings"
"sync"
"time"
@@ -41,7 +44,29 @@ type Ocr struct {
}
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
@@ -110,44 +135,87 @@ func (o *Ocr) workerLoop(ctx context.Context) {
}
// process exécute l'extraction pour un job déjà réclamé (`processing`).
// Ordre A13 : l'écriture `UpdateOcrText` est vérifiée AVANT le `Complete` —
// hôte supprimé entre-temps (0 ligne, ErrNotFound) → le job `Fail` au lieu
// de rester `done` avec un texte fantôme. Les erreurs `Fail`/`Complete`
// (conflit d'état : job requeue et repris par un autre worker) sont loggées,
// jamais silencieuses.
func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
fail := func(message string) {
if err := o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, message); err != nil {
log.Printf("ocr: fail job %s: %v", row.ID, err)
}
}
complete := func(text string) {
if err := o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text); err != nil {
log.Printf("ocr: complete job %s: %v", row.ID, err)
}
}
userID, err := o.Repository.Resources.GetResourceOwner(row.FileID)
if err != nil {
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable")
fail("file not readable")
return
}
path, err := o.physicalPath(userID, row.FileID)
if err != nil {
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable")
fail("file not readable")
return
}
text, err := o.Engine.ExtractText(ctx, path, o.Lang)
if err != nil {
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, err.Error())
fail(err.Error())
return
}
_ = o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text)
// Le texte atterrit sur la ressource (updated_at bumpé) : consultable par
// tous les devices du user et les grantees via GET /files/:id/ocr. SILENCIEUX
// (hôte déjà supprimé ou lock d'écriture) : le job reste source d'historique.
// tous les devices du user et les grantees via GET /files/:id/ocr.
if trimmed := strings.TrimSpace(text); trimmed != "" {
if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil {
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
// 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) {
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+".*"))
if err != nil {
return "", err
}
for _, m := range matches {
if strings.HasPrefix(filepath.Base(m), fileID+".") {
return m, nil
if !strings.HasPrefix(filepath.Base(m), fileID+".") {
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
}
+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) {
o, userID, deviceID, _ := newTestOcr(t, t.TempDir(), stubEngine{text: "x"})
+56
View File
@@ -0,0 +1,56 @@
package service
import (
"time"
"github.com/kazier/backend/repository"
)
// PlacementDTO serializes one byte-presence entry for
// GET /files/:id/placements. The `server` entry is implicit (derived from
// `resources.has_content`, no row) ; device entries come from client reports
// (`report_bytes` ops). `updatedAt` is RFC3339 (server entry: resource
// timestamp ; device entries: report timestamp).
type PlacementDTO struct {
LocationType string `json:"locationType"`
DeviceID string `json:"deviceId,omitempty"`
HasBytes bool `json:"hasBytes"`
UpdatedAt string `json:"updatedAt,omitempty"`
}
// ListPlacements returns byte presence of a resource the user OWNS (server
// entry + device reports, newest first). Non-owner → ErrNotFound (same
// owner-only scoping as shares/links reads).
func (s *Resources) ListPlacements(userID, resourceID string) ([]PlacementDTO, error) {
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return nil, err
}
if ownerID != userID {
return nil, repository.ErrNotFound
}
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return nil, err
}
out := []PlacementDTO{
{
LocationType: "server",
HasBytes: row.HasContent,
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
},
}
placements, err := s.Repository.Placements.ListForResource(resourceID)
if err != nil {
return nil, err
}
for _, p := range placements {
out = append(out, PlacementDTO{
LocationType: p.LocationType,
DeviceID: p.DeviceID,
HasBytes: p.HasBytes,
UpdatedAt: p.UpdatedAt.UTC().Format(time.RFC3339),
})
}
return out, nil
}
+265 -20
View File
@@ -4,9 +4,11 @@ import (
"errors"
"fmt"
"io"
"log"
"mime/multipart"
"os"
"path/filepath"
"regexp"
"strings"
"time"
@@ -16,6 +18,10 @@ import (
// ErrFileTooLarge signals an upload above MaxFileSize.
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.
type FileDTO struct {
ID string `json:"id"`
@@ -24,6 +30,7 @@ type FileDTO struct {
MimeType string `json:"mimeType,omitempty"`
FolderID string `json:"folderId,omitempty"`
Tags []string `json:"tags,omitempty"`
HasContent bool `json:"hasContent"`
CreatedAt string `json:"createdAt,omitempty"`
UpdatedAt string `json:"updatedAt,omitempty"`
}
@@ -53,6 +60,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) {
rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order)
if err != nil {
@@ -80,6 +147,79 @@ type FileOcrDTO struct {
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"
}
// Octets constatés : heal `has_content` → TRUE (V2 lazy, best-effort).
if !row.HasContent {
if herr := s.Repo.SetHasContent(ownerID, resourceID, true); herr != nil {
log.Printf("content: heal has_content(%s): %v", resourceID, herr)
}
}
return ContentInfo{Path: resolved, Name: row.Name, MimeType: mime, Size: fi.Size()}, nil
}
// Aucun octet mais flag TRUE (suppression manuelle sous UPLOAD_DIR) :
// heal → FALSE (V2 lazy, best-effort).
if row.HasContent {
if herr := s.Repo.SetHasContent(ownerID, resourceID, false); herr != nil {
log.Printf("content: heal has_content(%s): %v", resourceID, herr)
}
}
return ContentInfo{}, repository.ErrNotFound
}
// GetFileOcr returns the OCR text of a file the user can see (viewer+, own or
// shared). Absent text → Text empty ("") with 200 (the caller decides).
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
@@ -132,66 +272,170 @@ func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDT
// rename, never a move, never a duplicate row. Unknown / foreign resource →
// repo.ErrNotFound.
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
if file.Size > s.MaxFileSize {
return FileDTO{}, ErrFileTooLarge
// Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des
// composants de chemin. ownerID vient de l'auth mais on ne lui fait pas
// confiance aveuglément ; resourceID fourni par le client est déjà
// pré-validé côté handler (404), ici on rejete en NotFound/400 pareil.
if strings.ContainsAny(ownerID, "/\\\x00\n\r") || strings.Contains(ownerID, "..") {
return FileDTO{}, ErrInvalidUpload
}
targetExisting := resourceID != ""
if targetExisting {
if !idPattern.MatchString(resourceID) {
return FileDTO{}, repository.ErrNotFound
}
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
return FileDTO{}, err
}
} else {
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)
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)
}
// 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)
if err := copyMultipart(file, destPath); err != nil {
destName := resourceID
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
}
mimeType := file.Header.Get("Content-Type")
var err error
mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
var extPtr *string
if extension != "" {
extPtr = &extension
}
if targetExisting {
err = s.Repo.UpdatePhysical(ownerID, resourceID, file.Size, &mimeType, &extension)
err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
} 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 {
// Upload avec octets : `has_content` TRUE (V2 lazy).
err = s.Repo.SetHasContent(ownerID, resourceID, true)
}
}
if err != nil {
// Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique.
stillOld := false
for _, m := range oldMatches {
if m == destPath {
stillOld = true
break
}
}
if !stillOld {
_ = os.Remove(destPath)
}
return FileDTO{}, err
}
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
for _, m := range oldMatches {
if m != destPath && strings.HasPrefix(filepath.Base(m), resourceID+".") {
_ = os.Remove(m)
}
}
row, err := s.Repo.GetFile(ownerID, resourceID)
if err != nil {
// Lecture post-insert en échec : au moins logguer (cf. FEEDBACK #6).
// Sur création on tente en plus de retirer le fichier pour ne pas
// laisser d'orphelin (le client retry → NAME_CONFLICT → re-upload
// ciblé). Sur re-upload ciblé on ne touche à rien (données existantes).
log.Printf("upload: GetFile(%s) failed after persist: %v", resourceID, err)
if !targetExisting {
_ = os.Remove(destPath)
}
return FileDTO{}, err
}
return toFileDTO(row), nil
}
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()
if err != nil {
return fmt.Errorf("open multipart file: %w", err)
return 0, fmt.Errorf("open multipart file: %w", err)
}
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 {
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 {
return fmt.Errorf("copy upload: %w", err)
limited := io.LimitReader(src, maxSize+1)
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 {
@@ -201,6 +445,7 @@ func toFileDTO(row repository.FileRow) FileDTO {
Size: row.Size,
MimeType: row.MimeType,
FolderID: row.FolderID,
HasContent: row.HasContent,
CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
}
+202
View File
@@ -6,6 +6,7 @@ import (
"mime/multipart"
"os"
"path/filepath"
"strings"
"testing"
"github.com/kazier/backend/repository"
@@ -162,3 +163,204 @@ func TestUploadTargetUnknownIsNotFound(t *testing.T) {
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
import "github.com/kazier/backend/models"
type Services struct {
ConnectedUser *models.User
}
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, ""
}
// Stubs historiques UserCan* (toujours-true) supprimés — LOT 5 #11.
// L'autorisation V1 est portée par le scoping owner (`user_id`) dans
// repository.Resources + les grants `shares` (cf. docs/api-v1.md) :
// aucune fonction toujours-true ne doit subsister ici.
+106
View File
@@ -0,0 +1,106 @@
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.
// `granteeKind` is "user" or "group" (V2-6) ; `granteeUserId` carries the
// principal id either way, `username` its display name.
type ShareGrantDTO struct {
GranteeUserID string `json:"granteeUserId"`
GranteeKind string `json:"granteeKind"`
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
}
granteeID := g.GranteeUserID
if g.GranteeGroupID != "" {
granteeID = g.GranteeGroupID
}
out = append(out, ShareGrantDTO{
GranteeUserID: granteeID,
GranteeKind: g.GrantKind(),
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
}
+234 -47
View File
@@ -3,6 +3,7 @@ package service
import (
"encoding/json"
"errors"
"log"
"regexp"
"time"
@@ -22,6 +23,8 @@ const (
OpUpdateShare = "update_share"
OpCreateLink = "create_link"
OpRevokeLink = "revoke_link"
// V2 placements : un device signale la présence de ses octets.
OpReportBytes = "report_bytes"
)
// SyncOperation is one outbox entry (shadow of mobile PendingOperationRow).
@@ -65,6 +68,7 @@ type movePayload struct {
type sharePayload struct {
GranteeUserID string `json:"granteeUserId"`
GranteeGroupID string `json:"granteeGroupId"`
Access string `json:"access"`
Inherit *bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
@@ -84,6 +88,10 @@ type revokeLinkPayload struct {
Token string `json:"token"`
}
type reportBytesPayload struct {
HasBytes *bool `json:"hasBytes"`
}
func classifySyncError(err error) (string, string) {
switch {
case errors.Is(err, repository.ErrNameConflict):
@@ -92,33 +100,88 @@ func classifySyncError(err error) (string, string) {
return "NOT_FOUND", "target resource or folder not found"
case errors.Is(err, repository.ErrGranteeNotFound):
return "GRANTEE_NOT_FOUND", "the specified user does not exist"
case errors.Is(err, repository.ErrGroupNotFound):
return "GROUP_NOT_FOUND", "the specified group 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:
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
// scopées par l'UTILISATEUR (userID), l'idempotence reste par DEVICE
// (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) {
for i := range ops {
op := &ops[i]
if err := validateSyncOp(op); err != 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 {
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 already {
continue
if errors.Is(err, repository.ErrInvalidPayload) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil
}
if err := s.applySyncOp(userID, op); err != 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 !claimed {
// 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, deviceID, op); err != nil {
code, message := classifySyncError(err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil
}
if err := s.recordApplied(deviceID, op); err != nil {
return SyncResult{}, err
if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil {
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
@@ -136,7 +199,8 @@ func validateSyncOp(op *SyncOperation) error {
}
switch op.Operation {
case OpCreateResource, OpUpdateMetadata, OpMoveResource, OpDeleteResource,
OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink:
OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink,
OpReportBytes:
default:
return errors.New("unknown operation " + op.Operation)
}
@@ -146,7 +210,7 @@ func validateSyncOp(op *SyncOperation) error {
return nil
}
func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) error {
resourceID := derefString(op.ResourceID)
switch op.Operation {
case OpCreateResource:
@@ -167,29 +231,47 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
// Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon,
// cohérent avec move_resource). Ordre du SAF walk : parent avant enfant.
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 {
return err
}
}
var insertErr error
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
return s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension))
insertErr = s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension))
}
if insertErr != nil {
// 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:
// Owner can always rename. A shared resource can be renamed by an
// editor+ (docs §6.2 effective_access ranking). Below editor, or on
// a resource the caller cannot reach at all, we keep the documented
// terminal-state semantics: absent → no-op.
// Sémantique uniforme (A8) : toute ressource que l'appelant ne peut
// pas renommer — absente, d'autrui, ou partagée sous editor — halte
// en NOT_FOUND. Pas de no-op silencieux : un rename qui n'a rien
// 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)
if err != nil {
return err
}
if access.EffectiveRank < repository.AccessEditor {
if !access.Accessible {
return nil
}
return repository.ErrNotFound
}
var p renamePayload
@@ -199,16 +281,17 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
if p.Name == "" {
return errors.New("payload.name required")
}
// 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:
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if !exists {
return nil
}
// A8 : move owner-only. Source non-owned (absente OU d'autrui) →
// NOT_FOUND halt (MoveResource ne touche que les lignes owned).
// Pas de applied silencieux : un move qui n'a rien déplacé
// désynchroniserait le client.
var p movePayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
@@ -216,9 +299,36 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
if p.ToFolderResourceID == resourceID {
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)
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)
case OpShare, OpUpdateShare:
@@ -233,11 +343,36 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
case OpRevokeLink:
return s.applyRevokeLinkOp(ownerID, resourceID, op)
case OpReportBytes:
return s.applyReportBytesOp(ownerID, deviceID, resourceID, op)
default:
return errors.New("unknown operation " + op.Operation)
}
}
// applyReportBytesOp handles OpReportBytes: a device reports its byte
// presence (V2 placements). Scope is viewer+ (owned or shared,
// GetFileVisible) — a grantee downloading a shared file reports too.
// Invisible → ErrNotFound (no enumeration). Naturally idempotent ; the A9
// replay guard requires a FRESH operation_id per state change.
func (s *Resources) applyReportBytesOp(userID, deviceID, resourceID string, op *SyncOperation) error {
if derefString(op.ResourceType) != "file" {
return errors.New("resource_type must be 'file' for report_bytes")
}
if _, err := s.Repo.GetFileVisible(userID, resourceID); err != nil {
return err
}
var p reportBytesPayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.HasBytes == nil {
return errors.New("payload.hasBytes required")
}
return s.Repository.Placements.Report(userID, deviceID, resourceID, *p.HasBytes)
}
// applyShareOp handles OpShare and OpUpdateShare: upsert a user-to-user grant.
func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) error {
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
@@ -251,23 +386,22 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.GranteeUserID == "" {
return errors.New("payload.granteeUserId required")
// Cible : exactement un principal (user XOR groupe, V2-6).
isUser := p.GranteeUserID != ""
isGroup := p.GranteeGroupID != ""
if isUser == isGroup {
return errors.New("payload requires exactly one of granteeUserId, granteeGroupId")
}
if !resourceIDPattern.MatchString(p.GranteeUserID) {
if isUser && !resourceIDPattern.MatchString(p.GranteeUserID) {
return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
}
if isGroup && !resourceIDPattern.MatchString(p.GranteeGroupID) {
return errors.New("payload.granteeGroupId must be 32 lowercase hex chars")
}
rank := repository.AccessFromString(p.Access)
if rank < repository.AccessViewer || rank > repository.AccessEditor {
return errors.New("payload.access must be viewer, commenter, or editor")
}
// Validate grantee exists and is active.
if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
inherit := true
if p.Inherit != nil {
inherit = *p.Inherit
@@ -275,13 +409,38 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
var expiresAt *time.Time
if p.ExpiresAt != nil {
t := time.UnixMilli(*p.ExpiresAt)
if !t.After(time.Now()) {
return errors.New("payload.expiresAt must be in the future")
}
expiresAt = &t
}
if isUser {
// Validate grantee exists and is active.
if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
}
} else {
// Validate group exists (any group : ids are unguessable, no enum).
if _, err := s.Repository.Groups.Get(p.GranteeGroupID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGroupNotFound
}
return err
}
if err := s.Repository.Shares.UpsertGroup(resourceID, p.GranteeGroupID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
}
}
// 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.
@@ -303,10 +462,13 @@ func (s *Resources) applyRevokeShareOp(ownerID, resourceID string, op *SyncOpera
if !resourceIDPattern.MatchString(p.GranteeUserID) {
return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
}
// Revoke is idempotent: no-op if already revoked/missing.
_ = s.Repository.Shares.Revoke(resourceID, p.GranteeUserID)
// Revoke is idempotent: no-op if already revoked/missing — mais les vraies
// 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.
return s.Repo.TouchResource(resourceID)
return s.Repo.TouchOwned(ownerID, resourceID)
}
// applyCreateLinkOp handles OpCreateLink: create a public share link.
@@ -332,12 +494,15 @@ func (s *Resources) applyCreateLinkOp(ownerID, resourceID string, op *SyncOperat
var expiresAt *time.Time
if p.ExpiresAt != nil {
t := time.UnixMilli(*p.ExpiresAt)
if !t.After(time.Now()) {
return errors.New("payload.expiresAt must be in the future")
}
expiresAt = &t
}
if err := s.Repository.Shares.CreateLink(p.Token, resourceID, p.Access, expiresAt, ownerID); err != nil {
return err
}
return s.Repo.TouchResource(resourceID)
return s.Repo.TouchOwned(ownerID, resourceID)
}
// applyRevokeLinkOp handles OpRevokeLink: soft-revoke a public share link.
@@ -356,13 +521,35 @@ func (s *Resources) applyRevokeLinkOp(ownerID, resourceID string, op *SyncOperat
if !resourceIDPattern.MatchString(p.Token) {
return errors.New("payload.token must be 32 lowercase hex chars")
}
// Revoke is idempotent: no-op if already revoked/missing.
_ = s.Repository.Shares.RevokeLink(p.Token)
return s.Repo.TouchResource(resourceID)
// Revoke is idempotent: no-op if already revoked/missing — mais les vraies
// pannes DB remontent.
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 {
return s.Repository.Operations.Record(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload)
// checkNoCycle remonte la chaîne parentale depuis toFolder : si on rencontre
// 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 {
+356 -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) {
s := newServiceStore(t)
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)
}
// 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{
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "sneak.txt"}),
})
if err != nil {
t.Fatalf("stranger update: %v", err)
}
if result.Applied != 1 || result.Failed != nil {
t.Errorf("stranger update: attendu applied=1 aucun échec, got %+v", result)
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Errorf("stranger update: attendu applied=0 NOT_FOUND, got %+v", result)
}
row, err = s.Repo.GetFile(ownerID, fileID)
if err != nil || row.Name != "renamed.txt" {
@@ -1179,15 +1215,16 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) {
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{
syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}),
})
if err != nil {
t.Fatalf("grantee move: %v", err)
}
if result.Applied != 1 || result.Failed != nil {
t.Fatalf("grantee move: applied=%d failed=%+v", result.Applied, result.Failed)
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Fatalf("grantee move: attendu applied=0 NOT_FOUND, got %+v", result)
}
row, err := s.Repo.GetFile(ownerID, fileID)
if err != nil {
@@ -1197,17 +1234,327 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) {
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{
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
})
if err != nil {
t.Fatalf("grantee delete: %v", err)
}
if result.Applied != 1 || result.Failed != nil {
t.Fatalf("grantee delete: applied=%d failed=%+v", result.Applied, result.Failed)
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
t.Fatalf("grantee delete: attendu applied=0 NOT_FOUND, got %+v", result)
}
if _, err := s.Repo.GetFile(ownerID, fileID); err != nil {
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)
}
}
func TestApplyBatchReportBytes(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "report-owner")
granteeID := mustCreateUser(t, s.Repository, "report-grantee")
outsiderID := mustCreateUser(t, s.Repository, "report-outsider")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
otherDevice := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000001")
fileID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "r.txt"}),
syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{"granteeUserId": granteeID, "access": "viewer"}),
}); err != nil {
t.Fatalf("setup: %v", err)
}
report := func(user, device, res string, hasBytes bool) (SyncResult, error) {
return s.ApplyBatch(user, device, []SyncOperation{
syncOp(repository.NewID(), res, OpReportBytes, "file", map[string]any{"hasBytes": hasBytes}),
})
}
// Owner + grantee (viewer) peuvent reporter ; l'owner lit serveur + device.
if result, err := report(ownerID, deviceID, fileID, true); err != nil || result.Applied != 1 || result.Failed != nil {
t.Fatalf("report owner: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
if result, err := report(granteeID, otherDevice, fileID, true); err != nil || result.Applied != 1 || result.Failed != nil {
t.Fatalf("report grantee: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
placements, err := s.ListPlacements(ownerID, fileID)
if err != nil {
t.Fatalf("ListPlacements: %v", err)
}
if len(placements) != 3 {
t.Fatalf("attendu serveur + 2 devices, got %+v", placements)
}
if placements[0].LocationType != "server" || placements[0].HasBytes {
t.Errorf("entrée serveur = %+v, attendu hasBytes=false", placements[0])
}
// Changement d'état (drop) avec un NOUVEL operation_id ; hasBytes manquant → halt.
if result, err := report(ownerID, deviceID, fileID, false); err != nil || result.Applied != 1 || result.Failed != nil {
t.Fatalf("report drop: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
}
bad, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpReportBytes, "file", map[string]any{}),
})
if err != nil || bad.Applied != 0 || bad.Failed == nil || bad.Failed.Code != "INVALID_REQUEST" {
t.Errorf("hasBytes manquant: attendu halt INVALID_REQUEST, got %+v err=%v", bad, err)
}
// Outsider (invisible) → halt NOT_FOUND, sans énumération.
denied, err := report(outsiderID, otherDevice, fileID, true)
if err != nil || denied.Applied != 0 || denied.Failed == nil || denied.Failed.Code != "NOT_FOUND" {
t.Errorf("report outsider: attendu halt NOT_FOUND, got %+v err=%v", denied, err)
}
// Rejeu à l'identique → idempotent (skip, pas d'erreur).
replayID := repository.NewID()
first, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(replayID, fileID, OpReportBytes, "file", map[string]any{"hasBytes": true}),
})
if err != nil || first.Applied != 1 || first.Failed != nil {
t.Fatalf("report initial: %+v err=%v", first, err)
}
second, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(replayID, fileID, OpReportBytes, "file", map[string]any{"hasBytes": true}),
})
if err != nil || second.Applied != 1 || second.Failed != nil {
t.Errorf("rejeu identique: attendu skip idempotent, got %+v err=%v", second, 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:
+3 -3
View File
@@ -30,9 +30,9 @@ services:
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 (voir backend/.env.example)}
ADMIN_USERNAME: ${ADMIN_USERNAME:?ADMIN_USERNAME requis au premier démarrage}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:?ADMIN_PASSWORD requis au premier démarrage}
AUTH_SECRET: ${AUTH_SECRET:-dev-secret-change-me-please-set-in-prod}
ADMIN_USERNAME: ${ADMIN_USERNAME:-admin}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:-change-me}
volumes:
- backend-uploads:/app/uploads
depends_on:
+17 -4
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) |
| GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — |
| 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` |
| GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — |
| GET | `/files/folders` | — | `FolderDto[]` (racines) | — |
@@ -44,6 +45,15 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
| POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — |
| GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` |
| GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` |
| GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, granteeKind: "user"&#124;"group", username, access, inherit, expiresAt (ms&#124;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) |
| GET | `/files/:id/placements` | — (owner uniquement) | `Placement[]` (`{ locationType: "server"&#124;"mobile", deviceId?, hasBytes, updatedAt }`, entrée serveur en premier) | `NOT_FOUND` (non-owner ou inconnue) |
| POST | `/groups` | `{ "name" }` | `{ "id", "name", "role": "owner" }` | `INVALID_REQUEST` (nom vide/trop long) |
| GET | `/groups` | — | `Group[]` (`{ "id", "name", "role": "owner"&#124;"member" }`, possédés + rejoints) | — |
| POST | `/groups/:id/members` | `{ "userId": "…32-hex" }` | `{ "id": "…" }` | `NOT_FOUND` (groupe d'autrui/inconnu), `GRANTEE_NOT_FOUND` (membre inconnu) |
| GET | `/groups/:id/members` | — (owner uniquement) | `Member[]` (`{ "id", "username" }`) | `NOT_FOUND` |
| DELETE | `/groups/:id/members/:userId` | — | `{ "id": "…" }` | `NOT_FOUND` |
| DELETE | `/groups/:id` | — | `{ "id": "…" }` | `NOT_FOUND` (d'autrui/inconnu) |
| POST | `/sync/ops` | voir §6 | voir §6 | — |
| GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — |
@@ -59,6 +69,7 @@ type FileDto = {
mimeType?: string | null;
folderId?: string | null; // resource_id 32-hex
tags?: string[];
hasContent: boolean; // V2 : octets vus présents (lazy healing, FALSE = jamais constatés)
createdAt?: string;
updatedAt?: string;
};
@@ -104,7 +115,7 @@ type FileOcr = { text: string; updatedAt?: string | null };
}
```
- `operation` ∈ `create_resource | update_metadata | delete_resource | move_resource | share | revoke_share | update_share | create_link | revoke_link` (cf. `PendingOperationType` mobile).
- `operation` ∈ `create_resource | update_metadata | delete_resource | move_resource | share | revoke_share | update_share | create_link | revoke_link | report_bytes` (cf. `PendingOperationType` mobile).
- **Identifiants** : `operation_id` est un **TEXT 32-hex** généré par le client (`^[0-9a-f]{32}$`, CHECK-enforced depuis la migration `000008`), distinct de `resource_id`. L'idempotence outbox reste **par device** : `UNIQUE(device_id, operation_id)` (la réinscription d'un device avec un login différent ne réutilise pas l'historique outbox d'un autre compte). Pour chaque op : si déjà traitée → **no-op** (comptée comme appliquée, les doublons arrivent à cause du backoff/retry). Sinon appliquée si valide.
- **Ordre** : les opérations sont appliquées **séquentiellement**, dans l'ordre du batch. Le serveur **s'arrête à la première erreur non-idempotente** et renvoie l'index atteint — le client reprend à cet index.
- Réponse : `2xx` avec `{ "applied": int, "failed": { "operation_id": "…32-hex", "code": string, "message": string } | null }` (`applied` = index de la prochaine op à envoyer).
@@ -113,13 +124,14 @@ type FileOcr = { text: string; updatedAt?: string | null };
- `create_resource` : crée la ressource ; **déjà présente → no-op** (rejeu idempotent). `payload.name` obligatoire ; `payload.parentResourceId` (32-hex, optionnel) = dossier parent — absent → racine. **Parent inexistant → `NOT_FOUND`** (cohérent avec `move_resource`). Ordre garanti par construction client : le walk SAF émet les `create` des dossiers (ordre préfixe) avant ceux des fichiers, dans la même transaction Room → `id ASC` = parent avant enfant.
- `update_metadata` : ressource absente → **no-op** (état terminal atteint) ; **ressource partagée : nécessite `editor+`** (§6.2) — sinon `NOT_FOUND` (une ressource visible mais sans droit de mutation n'est pas renommée) ; une ressource sans relation applicable (ni owner, ni grant) reste un no-op (pas d'énumération). `move_resource` / `delete_resource` restent **owner-only** (scoping par `user_id`, les ops d'un non-owner sont des no-op).
- `delete_resource` : **idempotent** — suppression d'une ressource absente = succès.
- **Partage** (`share` / `update_share`, même sémantique d'upsert) : `payload = { "granteeUserId": "…32-hex", "access": "viewer"|"commenter"|"editor", "inherit"?: bool, "expiresAt"?: ms }`. La ressource doit **appartenir** au user appelant (sinon `NOT_FOUND`) ; le grantee doit exister (sinon `GRANTEE_NOT_FOUND`) ; accès déjà partagé → mis à jour (idempotent). Privilégier `viewer` < `commenter` < `editor` (< `owner` réservé à l'ownership, non partageable → `INVALID_REQUEST`).
- **Partage** (`share` / `update_share`, même sémantique d'upsert) : `payload = { "granteeUserId"?: "…32-hex", "granteeGroupId"?: "…32-hex", "access": "viewer"|"commenter"|"editor", "inherit"?: bool, "expiresAt"?: ms }` — **exactement un** principal (user XOR groupe, V2-6). La ressource doit **appartenir** au user appelant (sinon `NOT_FOUND`) ; le grantee user doit exister (sinon `GRANTEE_NOT_FOUND`), le groupe doit exister (sinon `GROUP_NOT_FOUND`) ; accès déjà partagé → mis à jour (idempotent). Privilégier `viewer` < `commenter` < `editor` (< `owner` réservé à l'ownership, non partageable → `INVALID_REQUEST`). Les membres d'un groupe partagé héritent du grant (un niveau, sans imbrication) dans le snapshot comme dans l'enforcement.
- `revoke_share` : `payload = { "granteeUserId": "…32-hex" }`. **Idempotent** (déjà révoqué/absent → no-op).
- `create_link` : `payload = { "token": "…32-hex", "access": "viewer"|"commenter"|"editor", "expiresAt"?: ms }`. Le token est **généré côté client** (`GenerateId`), c'est l'identifiant du lien (colonne `id` de `share_links`).
- `revoke_link` : `payload = { "token": "…32-hex" }`. **Idempotent**.
- **Présence multi-device** (`report_bytes`) : `payload = { "hasBytes": bool }` (**requis**). Le device signale ses octets locaux pour un fichier visible (`viewer+`, own ou partagé — sinon `NOT_FOUND`). Upsert idempotent par `(device, resource)` ; le rejeu à l'identique est no-op, mais chaque **changement d'état exige un nouvel `operation_id`** (garde anti-rejeu A9). Portée `file` uniquement.
- 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`.**
- **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>`
@@ -153,12 +165,13 @@ type ResourcePermission = {
### 6.3 Placements
- Le statut de placement (`sync_status` mobile : `local` | `cloud` | `local-cloud`) est le reflet du `resource_placements` serveur (statuts V2 : `local_only`, `synced`, `cloud_only`, `pending_upload`, `pending_download`). La matérialisation se fait via l'outbox (`create_resource` → `synced`/`pending_upload` ; suppression physique locale ≠ suppression serveur).
- **Présence multi-device (V2)** : les devices reportent leurs octets via l'op `report_bytes` (tables `storage_locations` + `resource_placements`, migration `000015`) ; le propriétaire lit `GET /files/:id/placements` (entrée `server` implicite depuis `has_content` + reports devices, owner-only). Hint de présence, jamais preuve — le serveur ne vérifie pas les octets distants.
## 7. Codes d'erreur courants
- Authentification : `UNAUTHORIZED` (**401** — token manquant/invalide/expiré, compte supprimé, OU identifiants de login erronés : **indistinguables par design**, même code+message), `INVALID_DEVICE_ID` (**400** — device non enregistré au login).
- Ressources : `NOT_FOUND` (404), `NAME_CONFLICT` (409 — même nom dans le même parent, cf. `UNIQUE(parent_id, name)`, **ou à la racine**, index partiel `(user_id, name) WHERE parent_id IS NULL`), `FILE_TOO_LARGE` (413), `INVALID_PASSWORD` (403 sur `PATCH /users/me/password`).
- Partage : `GRANTEE_NOT_FOUND` (404 — grantee inexistant sur une op share), `NOT_FOUND` (404 — ressource non possédée sur une op share : scoping, pas d'énumération).
- Partage : `GRANTEE_NOT_FOUND` (404 — grantee inexistant sur une op share), `GROUP_NOT_FOUND` (404 — groupe inexistant sur une op share ou un endpoint membres), `NOT_FOUND` (404 — ressource non possédée sur une op share : scoping, pas d'énumération).
- Client-only : `NETWORK_ERROR`, `INVALID_RESPONSE` (2xx mais corps d'enveloppe invalide), `HTTP_<status>` (fallback). Statut `SERVICE_UNAVAILABLE` (503) si le backend n'est pas initialisé.
- **V1 finale : toutes les routes sont réelles** (pas de 501 restant).
+26 -3
View File
@@ -1,7 +1,7 @@
[tasks.up_backend]
description = "Start PostgreSQL + backend API (Go/Gin)"
run = [
"docker compose up -d postgres --wait",
"if [ -f backend/.env ]; then docker compose --env-file backend/.env up -d postgres --wait; else docker compose up -d postgres --wait; fi",
"cd backend && go run cmd/server/main.go",
]
@@ -21,9 +21,32 @@ set -euo pipefail
./gradlew :app:assembleDebug -q
APK="app/build/outputs/apk/debug/app-debug.apk"
if [ "${usage_target?}" = "emulator" ]; then
adb -e install -r "$APK"
ADB_FLAGS=(-e)
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
'''
+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 {
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx)
@@ -0,0 +1,730 @@
{
"formatVersion": 1,
"database": {
"version": 16,
"identityHash": "ec10fdb23d5da3a76a73222e9c404561",
"entities": [
{
"tableName": "folders",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `exists` INTEGER, `parent_resource_id` TEXT, `owner_id` TEXT, `sync_status` TEXT NOT NULL, `created_in_app` INTEGER NOT NULL DEFAULT 0, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "uri",
"columnName": "uri",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "exists",
"columnName": "exists",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "parentResourceId",
"columnName": "parent_resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "syncStatus",
"columnName": "sync_status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdInApp",
"columnName": "created_in_app",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "addedAt",
"columnName": "added_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_folders_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_folders_uri",
"unique": true,
"columnNames": [
"uri"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_uri` ON `${TABLE_NAME}` (`uri`)"
},
{
"name": "index_folders_parent_resource_id",
"unique": false,
"columnNames": [
"parent_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_folders_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "user_preferences",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`key` TEXT NOT NULL, `value` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`key`))",
"fields": [
{
"fieldPath": "key",
"columnName": "key",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "value",
"columnName": "value",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"key"
]
},
"indices": [],
"foreignKeys": []
},
{
"tableName": "files",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `folder_resource_id` TEXT NOT NULL, `extension` TEXT, `size` INTEGER NOT NULL, `mime_type` TEXT, `exists` INTEGER, `last_modified` INTEGER, `owner_id` TEXT, `category` TEXT, `sync_status` TEXT NOT NULL, `content` TEXT, `processed` INTEGER NOT NULL, `ocr_text` TEXT, `ocr_attempts` INTEGER NOT NULL, `ocr_queued_at` INTEGER, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "uri",
"columnName": "uri",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "folderResourceId",
"columnName": "folder_resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "extension",
"columnName": "extension",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "size",
"columnName": "size",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "mimeType",
"columnName": "mime_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "exists",
"columnName": "exists",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "lastModified",
"columnName": "last_modified",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "category",
"columnName": "category",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "syncStatus",
"columnName": "sync_status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "content",
"columnName": "content",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "processed",
"columnName": "processed",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ocrText",
"columnName": "ocr_text",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "ocrAttempts",
"columnName": "ocr_attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ocrQueuedAt",
"columnName": "ocr_queued_at",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "addedAt",
"columnName": "added_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_files_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_files_uri",
"unique": true,
"columnNames": [
"uri"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_uri` ON `${TABLE_NAME}` (`uri`)"
},
{
"name": "index_files_folder_resource_id",
"unique": false,
"columnNames": [
"folder_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_folder_resource_id` ON `${TABLE_NAME}` (`folder_resource_id`)"
},
{
"name": "index_files_category",
"unique": false,
"columnNames": [
"category"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_category` ON `${TABLE_NAME}` (`category`)"
},
{
"name": "index_files_exists_processed_sync_status",
"unique": false,
"columnNames": [
"exists",
"processed",
"sync_status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` ON `${TABLE_NAME}` (`exists`, `processed`, `sync_status`)"
}
],
"foreignKeys": []
},
{
"tableName": "pending_operations",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_id` TEXT, `operation_id` TEXT NOT NULL, `ref_type` TEXT, `ref_id` INTEGER, `resource_id` TEXT, `resource_type` TEXT, `operation` TEXT NOT NULL, `payload` TEXT NOT NULL, `parent_resource_id` TEXT, `status` TEXT NOT NULL, `attempts` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "deviceId",
"columnName": "device_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "operationId",
"columnName": "operation_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "refType",
"columnName": "ref_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "refId",
"columnName": "ref_id",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "resourceType",
"columnName": "resource_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "operation",
"columnName": "operation",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "payload",
"columnName": "payload",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "parentResourceId",
"columnName": "parent_resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "attempts",
"columnName": "attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_pending_operations_device_id_operation_id",
"unique": true,
"columnNames": [
"device_id",
"operation_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_pending_operations_device_id_operation_id` ON `${TABLE_NAME}` (`device_id`, `operation_id`)"
},
{
"name": "index_pending_operations_status",
"unique": false,
"columnNames": [
"status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_status` ON `${TABLE_NAME}` (`status`)"
},
{
"name": "index_pending_operations_resource_id",
"unique": false,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_pending_operations_resource_id_operation_status",
"unique": false,
"columnNames": [
"resource_id",
"operation",
"status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` ON `${TABLE_NAME}` (`resource_id`, `operation`, `status`)"
},
{
"name": "index_pending_operations_parent_resource_id",
"unique": false,
"columnNames": [
"parent_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "scan_sessions",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `root_folder_id` TEXT, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "rootFolderId",
"columnName": "root_folder_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_scan_sessions_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_sessions_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "scan_pages",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `session_id` INTEGER NOT NULL, `temp_uri` TEXT NOT NULL, `corners_json` TEXT NOT NULL, `width` INTEGER NOT NULL, `height` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, FOREIGN KEY(`session_id`) REFERENCES `scan_sessions`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "sessionId",
"columnName": "session_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "tempUri",
"columnName": "temp_uri",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "cornersJson",
"columnName": "corners_json",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "width",
"columnName": "width",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "height",
"columnName": "height",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "sortOrder",
"columnName": "sort_order",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_scan_pages_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_pages_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_scan_pages_session_id",
"unique": false,
"columnNames": [
"session_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_session_id` ON `${TABLE_NAME}` (`session_id`)"
},
{
"name": "index_scan_pages_sort_order",
"unique": false,
"columnNames": [
"sort_order"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_sort_order` ON `${TABLE_NAME}` (`sort_order`)"
}
],
"foreignKeys": [
{
"table": "scan_sessions",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"session_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "resource_permissions",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`resource_id` TEXT NOT NULL, `resource_type` TEXT NOT NULL, `effective_access` TEXT NOT NULL, `owner_id` TEXT, `shared_by_id` TEXT, `expires_at` INTEGER, `cached_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`resource_id`))",
"fields": [
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "resourceType",
"columnName": "resource_type",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "effectiveAccess",
"columnName": "effective_access",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "sharedById",
"columnName": "shared_by_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "expiresAt",
"columnName": "expires_at",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "cachedAt",
"columnName": "cached_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"resource_id"
]
},
"indices": [
{
"name": "index_resource_permissions_expires_at",
"unique": false,
"columnNames": [
"expires_at"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` ON `${TABLE_NAME}` (`expires_at`)"
}
],
"foreignKeys": []
}
],
"views": [],
"setupQueries": [
"CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
"INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'ec10fdb23d5da3a76a73222e9c404561')"
]
}
}
@@ -0,0 +1,742 @@
{
"formatVersion": 1,
"database": {
"version": 17,
"identityHash": "97790c7bc08828c46cc63c36d628a327",
"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, `bytes_uploaded` INTEGER NOT NULL, `bytes_upload_attempts` INTEGER NOT NULL, `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": "bytesUploaded",
"columnName": "bytes_uploaded",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "bytesUploadAttempts",
"columnName": "bytes_upload_attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"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, '97790c7bc08828c46cc63c36d628a327')"
]
}
}
@@ -0,0 +1,754 @@
{
"formatVersion": 1,
"database": {
"version": 18,
"identityHash": "443cfaf8d993f1ce6f39b9b8ad67dd23",
"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, `bytes_uploaded` INTEGER NOT NULL, `bytes_upload_attempts` INTEGER NOT NULL, `has_content_server` INTEGER NOT NULL, `wanted_offline` INTEGER NOT NULL, `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": "bytesUploaded",
"columnName": "bytes_uploaded",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "bytesUploadAttempts",
"columnName": "bytes_upload_attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "hasContentServer",
"columnName": "has_content_server",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "wantedOffline",
"columnName": "wanted_offline",
"affinity": "INTEGER",
"notNull": true
},
{
"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, '443cfaf8d993f1ce6f39b9b8ad67dd23')"
]
}
}
@@ -41,6 +41,16 @@
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</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>
</application>
@@ -24,8 +24,10 @@ class MainActivity : ComponentActivity() {
super.onCreate(savedInstanceState)
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.
lifecycleScope.launch {
themePreferenceStore.load()
setContent {
val theme by themePreferenceStore.theme.collectAsStateWithLifecycle()
KazierTheme(theme = theme) {
@@ -33,4 +35,5 @@ class MainActivity : ComponentActivity() {
}
}
}
}
}
@@ -15,16 +15,20 @@ import javax.inject.Singleton
* Persistance chiffrée du token paseto et du profil compte (Keystore + AES).
* Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est
* JAMAIS écrit en clair dans SQLite.
*
* L'init Keystore/`EncryptedSharedPreferences` est paresseuse (m28) : aucun
* I/O au construct Hilt — le premier accès a lieu sur le thread de l'appelant
* ([SessionManager] bascule sur `Dispatchers.IO`).
*/
@Singleton
class SecureTokenStore @Inject constructor(
@ApplicationContext context: Context,
@ApplicationContext private val context: Context,
moshi: Moshi,
) {
) : TokenStore {
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)
EncryptedSharedPreferences.create(
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
return runCatching { userAdapter.fromJson(raw) }
.getOrNull()
?.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()
.putString(KEY_TOKEN, token)
.putString(KEY_ACCOUNT, userAdapter.toJson(user))
.apply {
if (expiresAt != null) putLong(KEY_EXPIRES_AT, expiresAt) else remove(KEY_EXPIRES_AT)
}
.apply()
}
fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).apply()
override fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).remove(KEY_EXPIRES_AT).apply()
}
companion object {
private const val FILE_NAME = "kazier_secure"
private const val KEY_TOKEN = "kazier.auth_token"
private const val KEY_ACCOUNT = "kazier.account"
private const val KEY_EXPIRES_AT = "kazier.expires_at"
private const val KEY_USERNAME = "kazier.auth_username"
private const val KEY_PASSWORD = "kazier.auth_password"
}
}
@@ -1,46 +1,210 @@
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.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.DeviceIdentity
import com.kazier.mobile.domain.LocalModeStore
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import timber.log.Timber
/** Événements de session vers l'UI (re-login silencieux, lot 3). */
sealed interface AuthEvent {
/** Le token a été renouvelé sans action utilisateur — rester connecté. */
data class Reauthenticated(val user: UserDto) : AuthEvent
/** Plus de session récupérable — afficher le login (pré-rempli si possible). */
data class SessionExpired(val username: String?) : AuthEvent
}
/**
* Orchestration de la session (restauration/sauvegarde/purge) : relie le store
* sécurisé, le miroir `active_user_id` et le token en mémoire lu par
* `AuthInterceptor`. Le drapeau « mode local » est persisté à part
* ([LocalModeStore]) pour survivre aux redémarrages.
*
* Le callback 401 est possédé ici (singleton, M25) — jamais par un ViewModel :
* après `onCleared`, un token expiré/révoqué continue d'être traité (le worker
* cesse alors de rejouer l'outbox sous un token mort).
*
* Re-login silencieux (lot 3) : les identifiants saisis au login sont
* persistés chiffrés ; sur 401 (ou token expiré détecté en proactif), une
* seule tentative de `POST /auth/login` est jouée (single-flight). Succès →
* [AuthEvent.Reauthenticated] (file conservée si même compte) ; identifiants
* rejetés → purge complète + [AuthEvent.SessionExpired]. La requête en vol
* ayant subi le 401 n'est PAS rejouée — l'appelant la relance (pull, retry).
*/
@Singleton
class SessionManager @Inject constructor(
private val secureTokenStore: SecureTokenStore,
private val tokenStore: TokenStore,
private val activeUserStore: ActiveUserStore,
private val tokenProvider: TokenProvider,
private val localModeStore: LocalModeStore,
private val pendingOperationDao: PendingOperationDao,
private val apiClient: ApiClient,
private val authRepository: AuthRepository,
) {
/** Restaure la session persistée (si présente), sinon null. */
suspend fun restore(): AuthSession? {
val token = secureTokenStore.getToken() ?: return null
val user = secureTokenStore.getUser() ?: return null
tokenProvider.current = token
return AuthSession(token = token, user = user)
private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
/** Single-flight du re-login : N 401 concurrents → 1 seul `POST /auth/login`. */
private val reloginMutex = Mutex()
private val _events = MutableSharedFlow<AuthEvent>(extraBufferCapacity = 4)
val events: SharedFlow<AuthEvent> = _events.asSharedFlow()
init {
// 401 sur un endpoint protégé (token expiré/révoqué, compte supprimé)
// → re-login silencieux puis purge si irrécupérable. Le 401 du login
// et des routes publiques est exonéré côté ApiClient
// (skipUnauthorizedHandling).
apiClient.onUnauthorized = { handleUnauthorized() }
}
suspend fun save(token: String, user: com.kazier.mobile.data.remote.dto.UserDto) {
secureTokenStore.save(token, user)
/** Restaure la session persistée (si présente), sinon null. */
suspend fun restore(): AuthSession? = withContext(Dispatchers.IO) {
val token = tokenStore.getToken() ?: return@withContext null
val user = tokenStore.getUser() ?: return@withContext null
tokenProvider.current = token
AuthSession(token = token, user = user, expiresAt = tokenStore.getExpiresAt())
}
suspend fun save(
token: String,
user: UserDto,
expiresAt: Long? = null,
username: String? = null,
password: String? = null,
) = withContext(Dispatchers.IO) {
val previousUserId = activeUserStore.get()
tokenStore.save(token, user, expiresAt)
if (username != null && password != null) {
tokenStore.saveCredentials(username, password)
}
activeUserStore.set(user.id)
localModeStore.clear()
tokenProvider.current = token
// Changement de compte sans sign-out explicite (login de B par
// dessus la session de A) : même purge que `clear()` — la file de
// A ne doit pas partir sous le token de B. Premier login
// (`previousUserId == null`, éventuel travail du mode local) et
// re-login du même compte : file conservée.
if (previousUserId != null && previousUserId != user.id) {
pendingOperationDao.deleteUnpushed()
}
}
suspend fun clear() {
secureTokenStore.clear()
suspend fun clear() = withContext(Dispatchers.IO) {
tokenStore.clear()
tokenStore.clearCredentials()
activeUserStore.clear()
tokenProvider.current = null
// Sign-out explicite : la file non poussée est abandonnée (C5, voir
// `deleteUnpushed`). Les ops `synced` survivent comme tombstones.
pendingOperationDao.deleteUnpushed()
}
/**
* 401 sur endpoint protégé (appelée depuis le thread OkHttp via
* `ApiClient`) : le token en mémoire tombe synchronement pour ne plus
* émettre de requêtes authentifiées, puis le re-login silencieux est tenté
* en IO (single-flight).
*
* Garde : sans session persistée (mode local, jamais connecté), un 401
* (token absent → `Bearer` omis → 401 serveur) ne signifie PAS une
* session morte — ignorer, sans purge ni événement. Sinon un appel
* égaré éjecte l'utilisateur local vers l'écran de login.
*/
fun handleUnauthorized() {
tokenProvider.current = null
scope.launch {
val hadSession = runCatching {
tokenStore.getToken() != null || tokenStore.getUser() != null
}.getOrDefault(false)
if (!hadSession) return@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()
@@ -52,5 +216,7 @@ class SessionManager @Inject constructor(
data class AuthSession(
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,
)

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