29 Commits
Author SHA1 Message Date
venture 4316da578f V3 S7 : preview cloud + export chiffré + release 1.2.0
Release / release-apk (push) Successful in 8m58s
Release / release-docker (push) Successful in 3m47s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m44s
CI / lint-mobile (push) Failing after 18m59s
CI / test-backend (push) Successful in 2m12s
CI / test-mobile (push) Successful in 8m50s
CI / build-backend (push) Successful in 45s
Backend : resource_previews (000024), GET /files/:id/preview (JPEG
512, images pur Go, PDF page 1 via pdftoppm + poppler au Dockerfile,
cache régénéré sur changement, 404 NO_PREVIEW sinon), POST /export
{password 8+} -> zip AES-256 streamé (fichiers vifs possédés +
manifest.json avec faits, metadata-only sans octets). Deps :
alexmullins/zip, x/image directs. Tests service + handlers + migrations.

Mobile : vignettes distantes (une requête/session puis cache WebP
versionné, garde tried, icône sinon), FileThumbnail cloud-only,
export (mot de passe jamais persisté, cache + partage FileProvider),
bouton Partager ACTION_SEND. Impression papier reportée V4. FR/EN.

Contrat docs/api-v1.md, V3.md (S7 livré, V3 close), AGENTS.md,
VERSION 1.2.0 + CHANGELOG.
2026-09-26 15:08:31 +02:00
venture 1e38e6e4ee V3 S6 : confiance (révocation, quota, appareils, conflits) + import + onboarding
Backend : token_version (000022, claim tv, 401 si révoqué, bump au
password — fin limite V1), quota (000023 idempotente, colonne héritée
de 000001, 413 QUOTA_EXCEEDED, GET /users/me/usage), devices
(GET + DELETE révocation, EnforceDeviceExists en prod), renames
concurrents transparents (baseUpdatedAt + conflicts[] non-fataux,
tolérance 2 s). Tests service + handlers + migrations + auth.

Mobile : pipeline conflits (DTO + SyncConflictStore + worker + dialogue),
baseUpdatedAt prêt, liens 7j par défaut, écran Appareils (+ quota),
import classeur unifié (scan/note/dossier), onboarding cercle Famille.

Contrat docs/api-v1.md, V3.md (S6 livré).
2026-09-26 11:56:39 +02:00
venture 37dc36f1f2 V3 S5 : graphe documentaire + doublons + collections
Backend : resource_links + scan_session_id (000021), réconciliation
déterministe (same_scan outbox, doublons SHA-256 à l'upload + backfill,
same_issuer/référence via faits effectifs, verdicts préservés, élagage
auto), GET /files/:id/relations + verdict (owner-only),
GET /duplicates (groupes + gain récupérable). Tests service + handlers
+ migrations.

Mobile (Room v22) : links + collections, scanSessionId dans les creates
de scan, LinksRepository (sync + verdicts REST), « Voir aussi » dans la
fiche (verdict infirmer/re-confirmer), écran Doublons (garder le plus
récent), collections locales (sauver/rejouer/supprimer). FR/EN.

Contrat docs/api-v1.md (/relations, pas /links — pris par le partage),
V3.md (S5 livré, version_of non matérialisé).
2026-09-26 11:16:35 +02:00
venture 2d984fd665 V3 S4 : recherche FTS + facettes (serveur + mobile)
Backend : search_tsv french + GIN (000020), SearchDocumentsVisible
(nom + TS + faits, rang nom > TS > fait sûr > fait douteux, jamais
d'exclusion), facettes issuer/type/montant/période sur
GET /files/search (400 si malformée). Tests repo + handlers + migrations.

Mobile (Room v21) : FTS4 files_fts + triggers partagés
(fresh-install/migration, entité déclarée pour KSP, SQL aligné 21.json),
searchDocuments offline (même rang, accents préservés) + UI filtres
(émetteur, types chips, montants, période ISO, compteur, effacer).

Contrat docs/api-v1.md, V3.md (S4 livré, migrations renumérotées
links->000021, token->000022).
2026-09-26 10:53:56 +02:00
venture ac8bd9acb4 V3 S3 : correction des faits (fiche document + correct_facts)
Backend : CorrectFacts (editor+, validation Go -> 400 jamais 500),
op outbox correct_facts (full-replace jeu user), PATCH
/files/:id/facts (renvoie jeu complet). Tests service + sync + handlers.

Mobile (Room v20) : table resource_facts + FactsDao, FactsRepository
(sync remplace-en-bloc, correction optimiste + outbox atomique),
fiche « Ce qu'on a compris » sur le viewer (chips, suggéré grisé,
édition par type, reset auto), bouton viewer si processed, FR/EN.

Contrat docs/api-v1.md, V3.md (S1-S3 livrés, FTS -> v21).
2026-09-26 10:28:33 +02:00
venture 95b4cf79cf V3 S1-S2 : corbeille + versions + extract générique
S1 filet (backend + mobile) : corbeille 30j (deleted_at réutilisé,
trash/restore récursifs, purge auto serveur), versions N=3 à chaque
overwrite, ops outbox trash/restore/purge (delete legacy mappé), Room
v19 (trashed_at), Deleters -> trash, écran Corbeille, walk guards.

S2 extract (backend) : package extract (règles FR stdlib, corpus
testé), resource_facts 000019 (origin auto/user), hook worker OCR +
backfill boot, GET /files/:id/facts (viewer+).

Contrat docs/api-v1.md étendu, V3.md (vision + plan).
2026-09-26 10:14:07 +02:00
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
306 changed files with 37339 additions and 2689 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
+28 -25
View File
@@ -2,7 +2,8 @@
# #
# Construit l'APK signé (assembleRelease), crée la Release Gitea avec l'APK en # 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 # asset (API, équivalent de `glab release create`), puis pousse l'image
# kazier-server sur le registre conteneur Gitea + Docker Hub (tag + latest). # 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 # 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`, # l'hôte et utilise le daemon Docker local (pas de conteneur `docker:27`,
@@ -17,7 +18,6 @@
# - RELEASE_API_TOKEN PAT scope write:repository (API : création Release) # - RELEASE_API_TOKEN PAT scope write:repository (API : création Release)
# - CONTAINER_REGISTRY_TOKEN PAT scope write:package (registre conteneur Gitea) # - CONTAINER_REGISTRY_TOKEN PAT scope write:package (registre conteneur Gitea)
# - CONTAINER_REGISTRY_USER utilisateur propriétaire du PAT ci-dessus # - CONTAINER_REGISTRY_USER utilisateur propriétaire du PAT ci-dessus
# - DOCKERHUB_USER DOCKERHUB_TOKEN PAT Docker Hub (push public)
name: Release name: Release
@@ -30,7 +30,6 @@ permissions:
env: env:
ANDROID_IMAGE: cimg/android:2024.01-node ANDROID_IMAGE: cimg/android:2024.01-node
DOCKERHUB_IMAGE: docker.io/thirdshop/kazier
# API Gitea (host de l'instance) # API Gitea (host de l'instance)
API_HOST: gitea.thirdshop.fr API_HOST: gitea.thirdshop.fr
@@ -53,6 +52,7 @@ jobs:
- name: Signer + assembler l'APK release - name: Signer + assembler l'APK release
working-directory: mobile-kotlin working-directory: mobile-kotlin
shell: bash
env: env:
RELEASE_KEYSTORE_B64: ${{ secrets.RELEASE_KEYSTORE_B64 }} RELEASE_KEYSTORE_B64: ${{ secrets.RELEASE_KEYSTORE_B64 }}
SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }} SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
@@ -80,25 +80,41 @@ jobs:
./gradlew :app:assembleRelease -q ./gradlew :app:assembleRelease -q
- name: Créer la Release Gitea + upload APK - name: Créer la Release Gitea + upload APK
shell: bash
env: env:
RELEASE_API_TOKEN: ${{ secrets.RELEASE_API_TOKEN }} RELEASE_API_TOKEN: ${{ secrets.RELEASE_API_TOKEN }}
run: | run: |
set -euo pipefail set -euo pipefail
VERSION="$(cat VERSION)" VERSION="$(cat VERSION)"
TAG="v${VERSION}"
API="https://${API_HOST}/api/v1" API="https://${API_HOST}/api/v1"
AUTH="Authorization: token ${RELEASE_API_TOKEN:?RELEASE_API_TOKEN manquant (PAT scope write:repository)}" 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()))')" NOTES_JSON="$(python3 -c 'import json;print(json.dumps(open("CHANGELOG.md", encoding="utf-8").read()))')"
PAYLOAD_JSON="$(TAG="v${VERSION}" 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"])}))')" # Idempotent : si la release du tag existe déjà (re-tag, retry du job),
RELEASE_JSON="$(curl -sSf -X POST "${API}/repos/${GITHUB_REPOSITORY}/releases" \ # la réutiliser au lieu d'échouer en 409.
-H "${AUTH}" \ if RELEASE_JSON="$(curl -sSf -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/tags/${TAG}" 2>/dev/null)"; then
-H "Content-Type: application/json" \ echo "Release ${TAG} existante — réutilisation."
-d "${PAYLOAD_JSON}")" 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="$(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}" : "${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 \ curl -sSf -X POST \
"${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=app-release.apk" \ "${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=app-release.apk" \
-H "${AUTH}" \ -H "${AUTH}" \
-F "attachment=@mobile-kotlin/app/build/outputs/apk/release/app-release.apk" -F "attachment=@${APK_PATH}"
release-docker: release-docker:
runs-on: ubuntu-24.04 runs-on: ubuntu-24.04
@@ -111,12 +127,14 @@ jobs:
token: ${{ secrets.GITEA_TOKEN }} token: ${{ secrets.GITEA_TOKEN }}
- name: Sanity daemon Docker hôte - name: Sanity daemon Docker hôte
shell: bash
run: | run: |
set -euo pipefail set -euo pipefail
docker info >/dev/null docker info >/dev/null
echo "daemon Docker hôte joignable" echo "daemon Docker hôte joignable"
- name: Login registre Gitea - name: Login registre Gitea
shell: bash
env: env:
CONTAINER_REGISTRY_TOKEN: ${{ secrets.CONTAINER_REGISTRY_TOKEN }} CONTAINER_REGISTRY_TOKEN: ${{ secrets.CONTAINER_REGISTRY_TOKEN }}
CONTAINER_REGISTRY_USER: ${{ secrets.CONTAINER_REGISTRY_USER }} CONTAINER_REGISTRY_USER: ${{ secrets.CONTAINER_REGISTRY_USER }}
@@ -129,6 +147,7 @@ jobs:
echo "REGISTRY_IMAGE=${API_HOST}/${OWNER_LC}/kazier" >> "$GITHUB_ENV" echo "REGISTRY_IMAGE=${API_HOST}/${OWNER_LC}/kazier" >> "$GITHUB_ENV"
- name: "Build + push (registre Gitea : vX.Y.Z + latest)" - name: "Build + push (registre Gitea : vX.Y.Z + latest)"
shell: bash
run: | run: |
set -euo pipefail set -euo pipefail
VERSION="$(cat VERSION)" VERSION="$(cat VERSION)"
@@ -144,19 +163,3 @@ jobs:
docker run --rm "$REGISTRY_IMAGE:v${VERSION}" --version docker run --rm "$REGISTRY_IMAGE:v${VERSION}" --version
docker push "$REGISTRY_IMAGE:v${VERSION}" docker push "$REGISTRY_IMAGE:v${VERSION}"
docker push "$REGISTRY_IMAGE:latest" docker push "$REGISTRY_IMAGE:latest"
echo "TAG=v${VERSION}" >> "$GITHUB_ENV"
- name: Push Docker Hub (tag + latest)
env:
DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USER }}
DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
run: |
set -euo pipefail
: "${DOCKERHUB_USER:?DOCKERHUB_USER manquant}"
: "${DOCKERHUB_TOKEN:?DOCKERHUB_TOKEN manquant}"
IMAGE="$DOCKERHUB_IMAGE"
echo "$DOCKERHUB_TOKEN" | docker login -u "$DOCKERHUB_USER" --password-stdin docker.io
docker tag "$REGISTRY_IMAGE:$TAG" "$IMAGE:$TAG"
docker tag "$REGISTRY_IMAGE:$TAG" "$IMAGE:latest"
docker push "$IMAGE:$TAG"
docker push "$IMAGE:latest"
+22 -20
View File
@@ -2,7 +2,7 @@
## Project Status ## Project Status
`backend/` (Go) et `mobile-kotlin/` (Kotlin/Android) ont du scaffolding en place. Le client mobile est **local-first** : il reflète le SAF dans une base Room (v7, migrations, DAO) et pousse les **métadonnées** de ses mutations locales via un **outbox transactionnel** (`pending_operations` + worker WorkManager → `POST /sync/ops`). Pas d'upload physique, pas d'OCR ni de recherche serveur côté client en V1. `backend/` (Go) et `mobile-kotlin/` (Kotlin/Android) ont du scaffolding en place. Le client mobile est **local-first** : il reflète le SAF dans une base Room (v22, 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é + vignettes `GET /files/:id/preview` en cache), OCR serveur consommé côté client, recherche locale via Room FTS (+ facettes, + recherche serveur exposée), export chiffré (`POST /export`).
## Architecture ## Architecture
@@ -38,11 +38,11 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- `config/` — env (`godotenv`, optionnel) + defaults: `PORT`, `DATABASE_URL`, `UPLOAD_DIR`, `MAX_FILE_SIZE_MB`, `OCR_LANG`, `AUTH_SECRET` (secret des tokens paseto), `ADMIN_USERNAME`/`ADMIN_PASSWORD` (bootstrap du premier admin) - `config/` — env (`godotenv`, optionnel) + defaults: `PORT`, `DATABASE_URL`, `UPLOAD_DIR`, `MAX_FILE_SIZE_MB`, `OCR_LANG`, `AUTH_SECRET` (secret des tokens paseto), `ADMIN_USERNAME`/`ADMIN_PASSWORD` (bootstrap du premier admin)
- `models/` — domain entities (users, devices, documents/resources, clients) - `models/` — domain entities (users, devices, documents/resources, clients)
- `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin) - `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin)
- `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs** — réels) ; middleware `RequireAuth` - `handlers/` — HTTP handlers (health, devices register/list/revoke, **auth/login**, **users resolve + change password (révoque les tokens) + usage**, files CRUD/upload/search (+facettes) , folders, **sync/ops + sync/permissions, ocr/jobs, files/:id/content, files/:id/preview, files/:id/shares, files/:id/links, files/:id/placements, files/:id/versions, files/:id/facts, files/:id/relations, trash, duplicates, export, groups CRUD + membres** — réels) ; middleware `RequireAuth` (+ révocation `tv`, devices si `EnforceDeviceExists`)
- `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`) - `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot, `OpenContent` (bytes streaming + 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→000008) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down) - `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→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`) - `ocr/` — OCR engine behind an interface (Tesseract system call, `OCR_LANG` défaut `fra+eng`)
- `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification bcrypt (timing-equal) - `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification argon2id (comparaison `subtle`, délai égalisé)
- File uploads stored in `backend/uploads/` - File uploads stored in `backend/uploads/`
- Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }` - Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }`
- Error format: `{ "error": { "code": "...", "message": "..." } }` - Error format: `{ "error": { "code": "...", "message": "..." } }`
@@ -52,39 +52,41 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- Entry point: `app/src/main/java/com/kazier/mobile/KazierApplication.kt` (Hilt + `HiltWorkerFactory`) + `MainActivity.kt` (Hilt) ; navigation Compose dans `ui/navigation/` (`NavGraph.kt`, `KazierApp.kt`) - Entry point: `app/src/main/java/com/kazier/mobile/KazierApplication.kt` (Hilt + `HiltWorkerFactory`) + `MainActivity.kt` (Hilt) ; navigation Compose dans `ui/navigation/` (`NavGraph.kt`, `KazierApp.kt`)
- Data layer — `data/`: - Data layer — `data/`:
- `data/local/` — Room SQLite (DB `dot.db`, **version 7**, `Migrations.kt` : tables `folders`, `files`, `user_preferences`, `pending_operations`) : entités Folder/File/UserPreference/PendingOperation, DAO, tri (`FileOrdering`) ; flag `processed` sur `files` (mode review « traiter », local au device, **gate de sync** : un fichier pas encore traité n'est jamais poussé) ; outbox transactionnel `pending_operations` (v7) - `data/local/` — Room SQLite (DB `dot.db`, **version 22**, `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`, `trashed_at`), `user_preferences`, `pending_operations` (+ `device_id`, `parent_resource_id`), `scan_sessions`, `scan_pages`, `resource_permissions`, `resource_facts`, `files_fts` (FTS4 + triggers `FtsTriggers`), `resource_links`, `collections`) : entités + DAO, tri (`FileOrdering`), schéma exporté (`app/schemas/`, m22) ; flag `processed` sur `files` (mode review « traiter », local au device, **gate de sync** : un fichier pas encore traité n'est jamais poussé) ; outbox transactionnel `pending_operations`
- `data/remote/` — Retrofit/Moshi : `ApiService.kt` + `dto/Dtos.kt` = **contrat HTTP** (`{ data, meta }`, erreurs `{ error: { code, message } }`) ; `ApiClient.kt` normalise les réponses ; interceptors OkHttp (`AuthInterceptor`, `ServerUrlInterceptor`) - `data/remote/` — Retrofit/Moshi : `ApiService.kt` + `dto/Dtos.kt` = **contrat HTTP** (`{ data, meta }`, erreurs `{ error: { code, message } }`) ; `ApiClient.kt` normalise les réponses ; interceptors OkHttp (`AuthInterceptor`, `ServerUrlInterceptor`) ; `SafMultipart.kt` (multipart SAF paresseux partagé upload OCR + V2)
- `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource`/`move_resource`/`delete_resource`, écrivains dans la même transaction Room que la mutation parente ; pour un fichier SAF, la mutation parente du `create_resource` est le **garder** de la review (`markProcessed`), et `hasCreateOperation` en garde l'unicité) - `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource` (+`scanSessionId` S5)/`move_resource`/`update_metadata` (+`baseUpdatedAt` S6)/`trash_resource`/`restore_resource`/`purge_resource` (V3, `delete_resource` legacy mappé serveur) + ops partage `share`/`update_share`/`revoke_share`/`create_link` (expiration 7j défaut)/`revoke_link` + `report_bytes` V2 (`{ hasBytes }`, nouvel `operation_id` par état) + `correct_facts` S3 (full-replace jeu `user`), é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`), `FactsRepository` (sync remplace-en-bloc + corrections optimistes), `LinksRepository` (graphe + verdicts REST), `TrashRepository` (restore/purge/convergence), `CollectionsRepository` (local), `DevicesRepository` (appareils + usage), `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 : - `features/` — logique descendue côté client :
- `sync/DeviceSync.kt` + `SafScanner.kt` — sync device↔SAF : **two-pass walk** (listing hors transaction puis upserts Room dans une seule transaction), réconciliation `exists = 0` (jamais de suppression), single-flight via `Mutex` ; les nouveaux **dossiers** sont journalisés dans l'outbox à la découverte, les **fichiers** uniquement au « garder » de la review (gate `processed`) - `sync/DeviceSync.kt` + `SafScanner.kt` — sync device↔SAF : **two-pass walk** (listing hors transaction puis upserts Room dans une seule transaction), réconciliation `exists = 0` (jamais de suppression), single-flight via `Mutex` ; les nouveaux **dossiers** sont journalisés dans l'outbox à la découverte, les **fichiers** uniquement au « garder » de la review (gate `processed`)
- `saf/` — `SafUris`, `SafFolderCreator`, `FileMover` (relocalisation SAF `DocumentsContract.moveDocument`, repli métadonnée seule ; le déplacement est poussé en `move_resource`), `SafFileDeleter` (suppression SAF + `delete_resource` atomique) - `saf/` — `SafUris`, `SafFolderCreator`, `FileMover` (relocalisation SAF `DocumentsContract.moveDocument`, repli métadonnée seule ; le déplacement est poussé en `move_resource`), `SafFileDeleter` (suppression SAF + `delete_resource` atomique), `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) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) - `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours, **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 ») - `sync/SyncViewModel.kt` — état du sync exposé à l'UI (`SyncStatus` : marche en cours, ops en attente, dernières opérations) via le badge header `ui/components/SyncStatusBadge.kt` + `SyncOperationsDialog.kt` (« liste des sync »)
- `auth/` — session (login user + token paseto) : `SessionManager`, `SecureTokenStore`, `TokenProvider` - `auth/` — session (login user + token paseto + **re-login silencieux** sur 401 via identifiants chiffrés persistés, single-flight, événements `Reauthenticated`/`SessionExpired`) : `SessionManager`, `SecureTokenStore`, `TokenProvider`, `TokenStore` (+ `Credentials`)
- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte + placeholder cloud-only), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local), `components`, `theme` - `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming + fiche faits/liens + partage ACTION_SEND), `search` (**recherche locale** via Room FTS + facettes + collections locales), `settings` (URL serveur + thème + stockage/retention + export chiffré + appareils + corbeille + doublons), `trash`, `duplicates`, `devices`, `facts` (bottom-sheet), `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`, `GenerateId` (identifiants 32-hex) - `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`) - `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`)
- Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env) - Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env)
- Client **local-first** : lecture via `GET /files/folders`, `GET /files` ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource`) ; `POST /devices`, `POST /auth/login` ; download/upload physique hors scope - Client **local-first** : lecture via `GET /files/folders`, `GET /files` (+ streaming distant `GET /files/:id/content` pour les fichiers cloud-only, jamais persisté) ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource` + ops partage) ; `POST /devices`, `POST /auth/login` ; upload physique limité au pipeline OCR (`POST /files/upload` + `resourceId` ciblé)
## Data Conventions ## Data Conventions
- Canonical identity for folders/files is `resource_id`: opaque 32-hex, generated locally (`GenerateId`), never reused. The physical `uri` (SAF) is nullable (NULL = cloud-only) and is the reconciliation key for the SAF walk (unique index, NULLs distincts). - Canonical identity for folders/files is `resource_id`: opaque 32-hex, generated locally (`GenerateId`), never reused. The physical `uri` (SAF) is nullable (NULL = cloud-only) and is the reconciliation key for the SAF walk (unique index, NULLs distincts).
- Similarly, `pending_operations.operation_id` is a client-generated 32-hex (`GenerateId`), the idempotency key of the outbox `UNIQUE(device_id, operation_id)` lettre contre les rejeux du worker. - `pending_operations.operation_id` est un **TEXT 32-hex** généré par le client (`^[0-9a-f]{32}$`, CHECK-enforced côté serveur depuis la migration `000008`), distinct de `resource_id`. L'idempotence outbox reste **par device** : `UNIQUE(device_id, operation_id)` (colonne `device_id` côté mobile depuis Room v12).
- `owner_id` is **nullable** in the Room schema; it is set at runtime from `DeviceIdentity.getOrCreate()` during the SAF walk. - `owner_id` is **nullable** in the Room schema; it is set at runtime from `DeviceIdentity.getOrCreate()` during the SAF walk.
- Folder/file `sync_status` is a **placement** state: `local` | `cloud` | `local-cloud`. It is not a push progress marker. - Folder/file `sync_status` is a **placement** state: `local` | `cloud` | `local-cloud`. It is not a push progress marker.
- Client storage: `user_preferences` (clé/valeur) pour l'identité device, le compte actif, l'URL serveur, le thème, le mode local. - Client storage: `user_preferences` (clé/valeur) pour l'identité device, le compte actif, l'URL serveur, le thème, le mode local.
- Outbox atomique : `create_resource`/`move_resource`/`delete_resource` sont écrits dans la **même transaction Room** que la mutation parente ; l'écrivain (repository) et le worker partagent ce contrat. En mode local (pas de token), le worker est no-op. **Gate `processed`** : un fichier SAF nouvellement découvert est importé localement mais poussé seulement au « garder » (`markProcessed`, qui enqueue le `create_resource` dans la même transaction, une seule fois via `hasCreateOperation`) — d'où le filtrage des documents par l'utilisateur avant toute synchro. Un `delete_resource` n'est journalisé que si un `create_resource` a existé (jamais pour un fichier non poussé). - Outbox atomique : `create_resource`/`move_resource`/`delete_resource` sont écrits dans la **même transaction Room** que la mutation parente ; l'écrivain (repository) et le worker partagent ce contrat. En mode local (pas de token), le worker est no-op. **Gate `processed`** : un fichier SAF nouvellement découvert est importé localement mais poussé seulement au « garder » (`markProcessed`, qui enqueue le `create_resource` dans la même transaction, une seule fois via `hasCreateOperation`) — d'où le filtrage des documents par l'utilisateur avant toute synchro. Un `delete_resource` n'est journalisé que si un `create_resource` a existé (jamais pour un fichier non poussé).
- Pas de cache de permissions côté client en V1 : le serveur reste la source de vérité pour l'accès (`GET /sync/permissions` non consommé par le client Kotlin). - Cache de permissions côté client : `ShareRepository` hydrate `resource_permissions` depuis `GET /sync/permissions` (delta + pull complet, TTL 24h → downgrade lecture seule) et expose `canAccess` ; le serveur reste la source de vérité.
## API Contract (V1) ## API Contract (V1)
- **Le client mobile est le contrat**: les formes d'endpoints dans `mobile-kotlin/.../data/remote/ApiService.kt` + `dto/Dtos.kt` sont autoritatives et doivent matcher exactement ; le serveur ne renégocie pas. Spec consolidée: `docs/api-v1.md`. - **Le client mobile est le contrat**: les formes d'endpoints dans `mobile-kotlin/.../data/remote/ApiService.kt` + `dto/Dtos.kt` sont autoritatives et doivent matcher exactement ; le serveur ne renégocie pas. Spec consolidée: `docs/api-v1.md`.
- **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine. - **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine **silencieusement** via les identifiants chiffrés persistés (`SecureTokenStore`, single-flight, événements `Reauthenticated`/`SessionExpired`), sans rejouer la requête en vol.
- **Bootstrap**: au premier démarrage, si `users` est vide, `ADMIN_USERNAME`/`ADMIN_PASSWORD` (env) créent le premier admin ; absents → le serveur refuse de démarrer. L'env n'écrase jamais un compte existant. Usernames résolus sur `username_normalized` (lowercase + trim), `GET /users/resolve` exact uniquement (pas d'énumération). - **Bootstrap**: au premier démarrage, si `users` est vide, `ADMIN_USERNAME`/`ADMIN_PASSWORD` (env) créent le premier admin ; absents → le serveur refuse de démarrer. L'env n'écrase jamais un compte existant. Usernames résolus sur `username_normalized` (lowercase + trim), `GET /users/resolve` exact uniquement (pas d'énumération).
- **Identifiers**: `resource_id` / `device_user_id` / `user_id` / share-link `token` / `operation_id` sont des **lowercase 32-hex** TEXT (`^[0-9a-f]{32}$`, CHECK-enforced), stockés tels quels côté serveur (pas de conversion UUID). Le mobile génère toujours 32-hex. - **Identifiers**: `resource_id` / `device_user_id` / `user_id` / share-link `token` / `operation_id` sont des **lowercase 32-hex** TEXT (`^[0-9a-f]{32}$`, CHECK-enforced), stockés tels quels côté serveur (pas de conversion UUID). Le mobile génère toujours 32-hex.
- **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) — le walk SAF garantit parent avant enfant dans l'ordre d'`id`. - **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) ; `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). (Endpoint existant côté serveur ; pas encore consommé par le client Kotlin.) - **Permissions snapshot**: le serveur pousse des snapshots `resource_permissions` (`effective_access` ranking viewer < commenter < editor < owner, `inherit`, `expires_at`, TTL 24h → read-only downgrade). Consommé par le client Kotlin (`ShareRepository` : hydratation + delta + `canAccess`).
- **Lecture partagée** : `GET /files/:id/shares` + `GET /files/:id/links` (owner uniquement, 404 sinon) exposent grants et liens au propriétaire ; `GET /files/:id/content` streame les octets (viewer+, `Range` supporté).
## Non-Goals (V1) ## Non-Goals (V1)
@@ -92,7 +94,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- On-device OCR - On-device OCR
- Full multi-tenant federation / public discovery - Full multi-tenant federation / public discovery
- Multi-writer sync conflicts (single-owner device identity) - Multi-writer sync conflicts (single-owner device identity)
- Upload physique client→cloud (métadonnées seules via l'outbox, download, OCR jobs, permissions) côté mobile Kotlin - Upload physique généralisé client→cloud et download persistant (seuls l'upload ciblé OCR et le streaming lecture existent, cf. `docs/api-v1.md`)
## References ## References
+43 -2
View File
@@ -5,10 +5,48 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
## [Unreleased] ## [Unreleased]
### Changé ## [1.2.0] - 2026-09-26
- **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é.
V3 « Le classeur qui comprend » : filet anti-perte, extraction générique,
recherche plein-texte + facettes, graphe documentaire, confiance & partage
sobre, preview cloud, export chiffré. Contrat consolidé (`docs/api-v1.md`),
vision et plan (`V3.md`).
### Ajouté ### Ajouté
- Corbeille V3 (S1 backend) : `DELETE /files/:id` = trash par défaut (`?mode=purge` = définitif), `POST /files/:id/restore`, `GET /trash` (paginé), trash/restore récursifs (subtree + chaîne d'ancêtres), purge auto serveur après 30j (`TrashRetention`, passe au boot + horaire).
- Versions V3 (S1 backend) : table `resource_versions` (N=3, élagage auto), historique figé à chaque overwrite (`Upload` ciblé), `GET /files/:id/versions` + `POST /files/:id/versions/:n/restore` (l'actuel est à son tour versionné), upload ciblé vers trashé → `NOT_FOUND`.
- Outbox : ops `trash_resource` / `restore_resource` / `purge_resource` (owner-only, `delete_resource` legacy mappé vers trash, même idempotence) ; purge d'octets best-effort côté serveur.
- Migrations `000017` (index corbeille) + `000018` (versions), contrat `docs/api-v1.md` §3/§6.1 étendu, test de contrat `router_test.go`.
- Extract générique V3 (S2 backend) : package `extract` (règles FR stdlib — dates/échéances/périodes/montants/émetteurs/références masquées/`doc_type` suggéré, confiances, corpus testé), table `resource_facts` (migration `000019`, `origin` auto/user), hook worker OCR (`OnText` + backfill boot borné, best-effort, anti-panic), `GET /files/:id/facts` (viewer+, `[]` si vide, 404 si trashé/étranger).
- Corrections V3 (S3) : `PATCH /files/:id/facts` + op `correct_facts` (full-replace du jeu `user`, editor+, validation Go → 400 jamais 500), Room v20 (`resource_facts` + `FactsDao`, migration 19→20), fiche « Ce qu'on a compris » sur le viewer (chips, confiance grisée + suggéré, édition par type, reset auto), `FactsRepository` (sync remplace-en-bloc, correction optimiste + outbox atomique), `GET /files/:id/facts` consommé côté client.
- Recherche V3 (S4) : colonne `search_tsv` (migration `000020`, `french`, index GIN) + `SearchDocumentsVisible` (nom LIKE + TS + faits, rang nom > TS > fait sûr > fait douteux, facettes émetteur/type/montant/période), `GET /files/search` étendu (400 si facette malformée), Room v21 (FTS4 `files_fts` + triggers partagés fresh-install/migration, entité déclarée pour KSP), `searchDocuments` offline (même rang, accents préservés) + UI filtres (émetteur, types chips, montants, période ISO, compteur, effacer).
- Relations V3 (S5) : table `resource_links` + `scan_session_id` (migration `000021`), réconciliation déterministe (same_scan via outbox, doublons via SHA-256 posé à l'upload + backfill boot, same_issuer/référence via faits effectifs, verdicts préservés, élagage auto), `GET /files/:id/relations` + verdict (owner-only), `GET /duplicates` (groupes + gain récupérable), Room v22 (links + collections), « Voir aussi » dans la fiche (verdicts en ligne), écran Doublons (garder le plus récent), collections locales (sauver/rejouer/supprimer depuis la recherche), `scanSessionId` dans les creates de scan.
- Confiance V3 (S6) : `token_version` (migration `000022`, claim `tv`, 401 si révoqué, bump au changement de mot de passe — fin de la limite V1), quota (colonne héritée de `000001`, `000023` idempotente, 413 `QUOTA_EXCEEDED` sur créations, `GET /users/me/usage`), appareils (`GET /devices`, `DELETE /devices/:id`, `EnforceDeviceExists` en prod, écran Appareils + quota), renames concurrents transparents (`baseUpdatedAt` + `conflicts[]` non-fataux, gracieuseté 2 s, pipeline mobile persistance + dialogue), liens à expiration 7j par défaut, import « classeur » unifié (scan/note/dossier), onboarding cercle Famille.
- Corbeille V3 (S1 mobile, Room v19) : colonne `trashed_at` (files + folders, migration 18→19), tombstone `exists = 0` (requêtes `exists = 1` inchangées), `FileDeleter`/`FolderDeleter`/`SafFileDeleter` → ops `trash_resource` (plus de `delete_resource` émis), garde walk anti-résurrection + reconcile, `TrashRepository` (restore/purge/convergence `GET /trash`/expiration locale 31j), écran Corbeille (Réglages → restore/purge avec confirmation), expiration tombstones dans `RetentionWorker`, dialogue de suppression rewordé (corbeille 30j, plus « irréversible »).
- Preview cloud V3 (S7) : table `resource_previews` (migration `000024`), `GET /files/:id/preview` (JPEG 512, images pur Go, PDF page 1 via `pdftoppm` + poppler au Dockerfile, cache régénéré sur changement, 404 `NO_PREVIEW` sinon), vignettes distantes côté mobile (une requête/session puis cache WebP versionné, garde `tried`, icône sinon).
- Export chiffré V3 (S7 C3) : `POST /export { password 8+ }` → zip AES-256 streamé (fichiers vifs possédés + `manifest.json` avec faits, tout chiffré, metadata-only sans octets), mobile (mot de passe jamais persisté, téléchargement cache, partage système via FileProvider), bouton Partager (ACTION_SEND local) sur le viewer — impression papier reportée (V4, pas de dep print).
## [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. - Pipeline de release CI (GitLab) : lint, tests backend/mobile, build Docker, signature APK release, publication GitLab Release + Docker Hub.
- `backend/Dockerfile` multi-stage : image de production avec Tesseract (fra+eng) embarqué, user non-root, labels OCI. - `backend/Dockerfile` multi-stage : image de production avec Tesseract (fra+eng) embarqué, user non-root, labels OCI.
- Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé). - Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé).
@@ -17,6 +55,9 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
- Licence AGPLv3, badge README, `CHANGELOG.md`. - Licence AGPLv3, badge README, `CHANGELOG.md`.
- Versioning Android aligné sur le `VERSION` racine (versionCode dérivé). - Versioning Android aligné sur le `VERSION` racine (versionCode dérivé).
### Changé
- **Renommage : VaultDrop → Kazier.** Marque, package Android (`com.kazier.mobile`), module Go (`github.com/kazier/backend`), binaire/image `kazier-server`, creds Postgres par défaut. Le code interne `dot.db` est conservé.
### Corrigé ### Corrigé
- Docs : en-tête `docs/api-v1.md` (référence à l'ancien client Expo remplacée par le client Kotlin), quickstart et docker de la doc Starlight. - Docs : en-tête `docs/api-v1.md` (référence à l'ancien client Expo remplacée par le client Kotlin), quickstart et docker de la doc Starlight.
- `.gitignore` racine (uploads, binaires, keystore, artifacts). - `.gitignore` racine (uploads, binaires, keystore, artifacts).
+128 -287
View File
@@ -1,317 +1,158 @@
# FEEDBACK — Audit backend Kazier # FEEDBACK — Audit bugs mobile-kotlin (local-first)
Date : 2026-09-21 > 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).
Scope : `backend/` (Go, Gin, Postgres, Paseto, Tesseract) > 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é**.
Mode : lecture seule, vérifié dans le code. > 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é.
But : autre agent relit et complète ci-dessous (voir § À compléter). > 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).
## Haute priorité Base paths : `mobile-kotlin/app/src/main/java/com/kazier/mobile/…`
1. **Route `GET /files/folders` masquée** — `backend/handlers/router.go:29-32` ---
`GET /files/:id` déclaré avant `GET /files/folders`. Gin peut capter `folders` comme `id="folders"` → 404 au lieu de la liste.
2. **`move_resource` sans check de cycle** — `backend/service/sync.go:204-219` ## ✅ Corrigés et retirés (vérifiés le 2026-09-24)
Seul `toFolder == resourceID` rejeté. Déplacer un parent dans son enfant crée un cycle, casse les CTE récursives (`depth<100`).
3. **`create_link` non-idempotent** — `backend/service/sync.go:337` → `backend/repository/shares.go` (`CreateLink` INSERT simple sur PK `token`) ### 🔴 Critiques : 9/9 corrigés
Rejeu même `operation_id` (crash entre apply et `Record`) → violation PK classée `INVALID_REQUEST` terminale, bloque tout l'outbox. Prévoir `ON CONFLICT DO NOTHING` comme `Operations.Record`. - **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).
4. **`AUTH_SECRET` défaut faible** — `backend/config/config.go:49` + `backend/pkg/auth/auth.go` ### 🟠 Majeurs corrigés (31)
Défaut `dev-secret-change-me`, juste `SHA256`, pas de check longueur/entropie → tokens paseto v4-local forgeables sur déploiements par défaut. 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).
5. **Upload : extension non sanitisée** — `backend/service/resources.go:148-154` ### 🟡 Mineurs corrigés dans `d89c0d0` (voir `git show --stat d89c0d0`)
`filepath.Ext(file.Filename)` client tel quel → `destPath = <user>/<id>.<ext>`. Cas `""` → fichier `id.`, cas `../../`, `/`, très long → traversal / orphelins / ambiguïté `Glob(id.*)` pour OCR. 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).
6. **Orphelins + stale bytes au re-upload** — `backend/service/resources.go:161-162` + `backend/service/ocr.go` ---
`UpdatePhysical` ne supprime pas l'ancien `<id>.<oldExt>`. `Glob` prend le premier match → OCR sur bytes périmés + fuite disque. Échec `GetFile` après `InsertFile` réussi laisse aussi le fichier.
7. **`ApplyBatch` non-atomique** — `backend/service/sync.go:103-125` ## 🟠 Majeurs restants (4) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts)
`Applied() → apply → Record()` sans transaction. TOCTOU sur batches concurrents même `(device_id,operation_id)`, replay après crash, `Record` en 500 avec `applied` inconnu.
8. **Fuite d'erreurs internes** — `backend/handlers/store.go:20-33` + `backend/service/sync.go:87-98` - **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é.
Défaut `500 err.Error()` / `INVALID_REQUEST err.Error()` expose SQL/FS/paths au client. - **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.
9. **`Count()` bloque le bootstrap** — `backend/repository/users.go` + `backend/service/bootstrap.go` ---
Compte les soft-deleted. Tous users supprimés → plus jamais de nouvel admin, lock définitif. Devrait filtrer `WHERE deleted_at IS NULL`.
10. **Migrations destructives / irréversibles** ## 🟡 Mineurs restants (8) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts)
- `backend/db/migrations/000007_resources_user_ownership.up.sql:7` fait `DELETE FROM resources` à l'upgrade (wipe prod).
- `backend/db/migrations/000008_operation_uuid.down.sql` fait `operation_id::bigint` → casse dès que des IDs 32-hex avec `a-f` existent.
11. **Stubs dangereux** — `backend/service/services.go`, `move.go`, `upload.go`, `folders.go` ### Sync / Worker / SAF
`UserCan*` toujours `true`, no-ops. Si jamais câblés = bypass auth total. À supprimer. - **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.
12. **Oracle `INVALID_DEVICE_ID` au login** — `backend/handlers/auth.go:55-81` ### Room / Domain / DI
Check device après `VerifyTimedEqual`. Creds valides + device inconnu → 400 vs 401 → oracle + pas de rate-limit. - **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.
## Priorité moyenne (phase 2) ### 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.
- `DeviceID` login non validé `^[0-9a-f]{32}$` (`backend/handlers/auth.go:50` vs `devices.go:23`), `folderId/fileId/token` jamais validés hex avant DB. ---
- `POST /sync/ops` non borné (`backend/handlers/sync.go`) : pas de `MaxBytesReader`, pas de cap batch (client=20) → DoS OOM.
- `ParentResourceID/ToFolder` non validés hex → mal classés `NOT_FOUND`.
- `UpdateNameByID`, `TouchResource` non scopés owner (reposent que sur l'appelant) — TOCTOU.
- `Revoke/RevokeLink` : erreurs swallow `_ =` → masque vraies pannes (`backend/service/sync.go:306-309,359-361`).
- OCR : `Create` owner-only mais `GetFileOcr` viewer+, `Get` job scopé `device_id` → 2e device du même user = 404. PDF ignore `ctx`, pas de cap taille/pages, stderr (avec paths) exposé (`backend/ocr/tesseract.go:47-66`).
- `passwd.Verify` parse `m=` du hash stocké sans cap → ligne DB compromise = OOM Argon2 au login (`backend/pkg/passwd/passwd.go:74-88`).
- `POST /devices` public sans rate-limit → remplissage table. `MarkUser` permet à n'importe qui de claim n'importe quel `device_id` (`backend/repository/devices.go:36-42`).
- `getInt` sans range check (PORT/WORKERS/MAX négatifs acceptés) (`backend/config/config.go:64-70`).
- `ChangePassword` ne révoque pas les tokens (fenêtre 7j) (`backend/handlers/auth.go:113-151`).
- `expiresAt` passé accepté pour shares/links → grants instantanément expirés.
- `Snapshot/ListOwned` `LIMIT 10000` sans pagination → troncation silencieuse (`backend/repository/shares.go:199`, `resources.go:547`).
- Positif : pas d'injection SQL trouvée (tout en `$n`, `sortClause` whitelist).
## Plan proposé ## 🛠️ Plans de correction (reliquat) — ✅ implémentés le 2026-09-24
1. **P0 robustesse** : ordre routes, cycle move, idempotence `CreateLink`, transaction `ApplyBatch`, secret requis en prod, sanit `extension` + cleanup orphelins. Ordre suivi : M13 → M5 → M27+m21 → M9 → mineurs par lot (m1+m2, m5, m7, m20, m15+m19).
2. **P1 data** : fix `Count()` soft-deleted, corriger migrations 000007/000008, supprimer stubs, mapper erreurs sans fuite. É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).
3. **P2 durcissement** : validation hex systématique, cap `sync/ops`, rate-limit login/devices, cap Argon2 + PDF/OCR, scope `Touch/UpdateName`, pagination snapshot.
## À compléter (pour le relecteur) ### 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.
- Ajouter nouveaux bugs ci-dessous avec `fichier:ligne`, sévérité, explication courte. ### M9 — `FolderMerger` multi-transactions non-atomique
- Ne pas supprimer les entrées existantes, juste append ou annoter. Fichier : `features/saf/FolderMerger.kt:53-106`.
- Idées à creuser : `handlers/files.go` (`intParam`, `q` non borné), `service/resources.go:164` (filename brut comme `name`, mime verbatim), `repository/resources.go` (parent check puis UPDATE non-atomique → FK 500), `cmd/server/main.go` (double pool, `conn` jamais `Close`, worker OCR non attendu), `pkg/auth` (TTL 7j sans refresh/révocation). 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.
### Ajouts relecteur (2026-09-21, vérifié en lecture) ### 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`.
> Nota : entrées existantes conservées. Ci-dessous uniquement des ajouts. ### M27 — snapshot permissions sans delta ni `canAccess`
> Annotation §1 : `GET /files/folders` vs `GET /files/:id` — Gin privilégie 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`.
> les segments statiques sur `:param` dans son arbre, donc l'ordre de 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.
> déclaration (`router.go:29-32`) ne masque pas forcément `folders` en Plan :
> pratique. Reste fragile (dépend du routeur) : à verrouiller par un test 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).
> `GET /files/folders → 200` + `GET /files/<32hex> → 200/404`, pas par l'ordre. 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.
#### A1 — CRITIQUE : bypass dummy-password + panic nil-deref au login ### m1+m2 — badge sync et réveils WorkManager
- `backend/pkg/passwd/passwd.go:37-43,98-103` + `backend/handlers/auth.go:55-83` Fichier : `features/sync/SyncViewModel.kt:100-137`.
- `VerifyTimedEqual("", dummy)` vérifie contre `Hash("kazier-constantime-dummy")` Plan :
en dur. `username=<inconnu> + password="kazier-constantime-dummy"` → `Verify` 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).
retourne `nil` → suite du handler avec `user == nil` → `user.ID:83` panic 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.
(Gin recovery → 500). Effets : DoS à la demande + oracle 500 vs 401 qui casse Tests : Robolectric `SyncViewModelTest` — annulation du scope → flag retombe ; tick sans changement → `WorkManager` non sollicité (mock/static ou extraction d'un `SyncScheduler` testable).
l'indistinguabilité revendiquée + préimage hardcodée en source. Fix :
dummy aléatoire par boot (ou hash du mot fourni à sel fixe) + ne jamais
toucher `user` si `userErr != nil`.
#### A2 — Upload : `file.Size` fait confiance au header, `io.Copy` illimité ### m5 — walk : transaction géante + `getAll()` par racine
- `backend/service/resources.go:135,178-195` (service) vs `backend/handlers/files.go:119-133` (handler) Fichier : `features/sync/DeviceSync.kt:67-163`.
- Le handler protège le transport (`MaxBytesReader`), mais l'invariant Plan :
service est absent : header menteur → écriture disque illimitée. Envelopper 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.
`src` dans `io.LimitReader` + re-contrôler les octets écrits. 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.
#### A3 — Upload non-atomique, torn reads OCR ### m7 — recherche `LIKE` sans `ESCAPE`
- `backend/service/resources.go:154-157,178-195` Fichier : `data/local/dao/FileDao.kt:42-49`.
- `os.Create(dest)` + `io.Copy` direct, overwrite sur place pour 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.
`targetExisting`. `service/ocr.go` (`Glob`) peut lire un fichier à moitié Tests : `SearchFieldTest` ou nouveau `SearchEscapeTest` — `%` littéral ne matche pas tout, `_` littéral, insensible à la casse.
écrit. Fix : temp + `Rename` (+ `Fsync`).
#### A4 — Fichiers world-readable ### m20 — `OcrRepository.poll()` infini
- `backend/service/resources.go:149-150` : `MkdirAll 0755`, `os.Create` → 0644 Fichier : `data/repository/OcrRepository.kt:66-73`.
selon umask. Données user lisibles sur hôte partagé. Passer en `0700/0600`. 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 ».
- Positif vérifié : pas de traversal via `ownerID/resourceID` (32-hex issus Tests : `OcrRepositoryTest` — job restant `processing` → timeout au bout de N polls (fake `ApiClient` + virtual time/delays courts).
token/serveur), `UPLOAD_DIR` = config admin.
#### A5 — `NewID()` panic sur échec entropie ### m15+m19 — robustesse DB (downgrade + `exportSchema`)
- `backend/repository/resources.go:23-29` : `panic` si `crypto/rand` échoue → Fichiers : `di/DatabaseModule.kt:25-28`, `data/local/AppDatabase.kt:31-38`.
crash serveur entier. Retourner `(string,error)`. 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).
#### A6 — `ShareLinkGet` compare avec `==` au lieu de `errors.Is` ### m21 — ops contrat non émissibles
- `backend/handlers/share_links.go:23` (tous les autres handlers via 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`).
`writeError` utilisent `errors.Is`) : `ErrNotFound` wrappé → 500 au lieu de 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.
404, sur endpoint public non-authentifié → oracle 500/404. Tests : `OutboxSyncWorkerTest`-style — sérialisation payload, `normalizePayloadNumbers` (`expiresAt` Long exact, non `1.7E12`), round-trip `POST /sync/ops` mocké.
#### A7 — Incohérences contrat / parsing silencieux (mineurs mais réels) ---
- `backend/handlers/auth.go:94-96` : `ExpiresAt = Now()+TTL` seconde lecture
d'horloge, pas le `exp` du token (dérive ms).
- `backend/handlers/auth.go:90` : code `TOKEN_ERROR` non-standard.
- `backend/handlers/files.go:114-117,50-53` : 32-hex malformé → `404`, vs
`backend/handlers/devices.go:23-26` → `400 INVALID_DEVICE_ID`.
- `backend/handlers/files.go:13-22` + `backend/handlers/sync.go:43-47` :
`intParam` invalide/négatif → `fallback` silencieux ; `after` garbage →
`0` = full snapshot au lieu de 400. `Atoi` 32-bit overflow pour epoch-ms.
- `backend/handlers/middleware.go:29` : préfixe `Bearer ` case-sensitive.
#### A8 — Sémantiques silencieuses outbox (désync grantees + fuite d'existence) ## ✅ Vérifié infondé (suspects écartés)
- `backend/service/sync.go:180-202` : `update_metadata` cible absente → `nil` - Single-flight `Mutex` présent (`DeviceSync.kt:49`), `enqueueUniqueWork(KEEP)` + batch 20 + `ORDER BY id` conformes — non-bugs.
marqué *applied* (client croit le rename fait) vs `<editor` → `ErrNotFound` - `checkHealth` construit bien `{base}/health` avec base incluant `/api/v1` = route backend `GET /api/v1/health` — OK.
(batch halté). Incohérent. - Token **non** stocké en clair (`EncryptedSharedPreferences` AES256-SIV/GCM + Keystore) — seul `TokenProvider.current` en mémoire, normal.
- `backend/service/sync.go:204-222` : `move`/`delete` sur ressource partagée - Ordre interceptors `serverUrl → auth → logging`, `BASIC` ne log ni headers ni bodies — OK.
non-owned → no-op silencieux marqué applied → client grantee désync. - 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.
- `backend/service/sync.go:152-178` : `ExistsOwner` (own seul) puis `Insert` ; - `device_id` claim jamais utilisé comme preuve, seul le `Bearer` parle — conforme middleware.
id d'autrui deviné → PK globale → `23505 → ErrNameConflict` - Worker no-op en mode local (`OutboxSyncWorker.kt:111`), batch 20 ≤ 100 serveur, statuts OCR, `resolveUser` trim compatible, password jamais trimé — OK.
(`repository/resources.go:143-146`) = oracle d'existence cross-user. + TOCTOU - Deep-links : aucun défini (absence, pas de bug) ; args nav `folderResourceId`/`documentResourceId`/`ids` cohérents, 32-hex sans `/`.
`Exists→Insert`. - 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.
#### A9 — Replay à payload muté avalé - Scan : pas de double-`recycle` draft, pas de double rotation EXIF (comportement correct, commentaire trompeur), `swapOrder` args corrects, FK `scan_pages→sessions CASCADE` actif.
- `backend/service/sync.go:109-115` + `backend/repository/operations.go:44-50`
(`ON CONFLICT DO NOTHING`) : même `(device,op)` avec payload différent =
skip « succès », nouvelle intention dropée sans comparaison de hash.
#### A10 — `UpdatePassword` / `MarkDeleted` sans garde
- `backend/repository/users.go:87-103` : pas de `AND deleted_at IS NULL`, pas
de check `RowsAffected` → re-hash d'un compte soft-deleted, succès
silencieux sur id inconnu / course avec `MarkDeleted`.
#### A11 — `OcrJobs` : transitions sans garde
- `backend/repository/ocr_jobs.go:60-67,112-128` : `TouchProcessing`,
`Complete`/`Fail` sans garde de statut ni `RowsAffected` → `queued→done`,
`done→failed`, double-complete silencieux. `ResetStaleProcessing:100-110`
sur horloge app (skew DB), lignes `processing` à `started_at NULL` jamais
requeued. `ClaimNext:72-95` correct atomiquement mais sans index composite
`(status,created_at)` → scan O(queue).
#### A12 — `physicalPath` via `Glob` sans vérification fichier
- `backend/service/ocr.go:142-153` : symlink/répertoire/`id.` acceptés ;
symlink hors `UPLOAD_DIR` suivi par tesseract. Faire `Lstat + IsRegular +
EvalSymlinks`-containment. `lang` (`ocr/tesseract.go:30`, depuis `OCR_LANG`)
non whitelisté (argv, pas de shell — worst case erreur tesseract).
#### A13 — OCR : causes avalées, `done` trompeur
- `backend/service/ocr.go:113-138` : `Fail("file not readable")` sans `err`,
`Complete`/`UpdateOcrText` partiellement log-only → job `done` alors que
`ocr_text` non persisté ; `GET /files/:id/ocr` renvoie `""` 200
indistinguable de « pas encore extrait ».
- `backend/ocr/tesseract.go:29-45,47-67` : pas de timeout par job (ctx = vie
serveur), stdout/stderr non bornés → OOM, pages PDF en erreur `continue`
silencieusement → texte partiel vu comme complet, pas de cap taille/pages.
#### A14 — `main.go` : lifecycle / concurrence boot
- `backend/cmd/server/main.go:44-51,59` : `db.Open` + `MigrateDatabase` (qui
ouvre son propre pool) = double pool ; `conn` jamais `Close` ; migrations
DDL à chaque boot (rôle runtime devrait être DML-only en prod).
- `backend/service/bootstrap.go:25-47` : double réplica sur DB vide →
duplicate `username_normalized` → un réplica `Fatal`, pas de retry.
#### A15 — Complément device/token (étend § moyenne existant)
- Vérifié : `pkg/auth/auth.go:54-67` `Verify` n'impose pas `^[0-9a-f]{32}$` ;
`handlers/middleware.go:46-62` vérifie que le user existe mais jamais le
device (hex ni `Exists`) → tokens à device supprimé/jamais-enregistré
passent l'auth, 500 plus tard (FK). `repository/operations.go:36-51`
valide `operation_id` mais pas `device_id` ; payloads vides/`"null"`/invalides
normalisés en `{}` (`60-68`) au lieu d'être rejetés → trace infidèle.
#### A16 — Idées à creuser : conclusions
- `handlers/files.go:q` : `TrimSpace` + `!= ""` ok, mais pas de longueur maxi
→ `ILIKE %…%` géant = full scan (index trigram manquant,
`repository/resources.go:297,327`). `page/pageSize` cappés à 200 côté
handler, mais `(page-1)*pageSize` non cappé + repo sans validation
(`repository/resources.go:170-227`, `LIMIT` négatif → 500).
- `service/resources.go:159,164` : confirmé — `file.Filename` brut comme `name`
(sauts de ligne, 255+ chars, unicode) + `Content-Type` verbatim comme mime,
sans whitelist/normalisation.
- `repository/resources.go:124-147,374-403` : confirmé — `folderExists(SELECT)`
puis `INSERT`/`UPDATE` non-atomique → parent supprimé entre les deux = 500
FK ou orphelin.
- `cmd/server/main.go` : confirmé ci-dessus (A14) + worker OCR non attendu au
shutdown (5s puis exit, jobs `processing` → requeue au prochain boot via
`ResetStaleProcessing`, ok mais à documenter).
- `pkg/auth` : TTL 7j sans refresh/révocation confirmé par design
(`auth.go:13`, `handlers/auth.go:110-112`) ; `iat=nbf=now`, `exp` vérifié via
`NewParserForValidNow` (`auth.go:55`) — correct, pas de bug ici au-delà du
secret (A-suite § haute prio n°4) et du format non validé (A15).
## Validation (2026-09-21, autre agent — suite verte)
`go build ./...` OK. `go test ./...` : 11 packages OK, 0 fail
(`cmd/server, config, db, handlers, ocr, pkg/api, pkg/auth, pkg/passwd,
repository, service`). Les 4 échecs transitoires vus pendant l'édition
concurrente (RecordNormalizes, MarkDeleted, UploadSanitizes,
UpdateMetadata/Move) ne se reproduisent plus — tests alignés sur la
nouvelle sémantique.
### Haute priorité : tout corrigé
- §1 route `folders` : réordonnée avant `:id` + tests d'ordre (durcissement,
Gin préférait déjà le statique).
- #2 cycle : `checkNoCycle` (walk `GetParentID` ≤128) + `MoveResource`
atomique. Manque : pas de test cycle dédié.
- #3 `CreateLink` : `ON CONFLICT DO NOTHING` + même ressource → no-op,
sinon `NAME_CONFLICT`. Tests rejeu/conflit OK.
- #4 secret : défaut allongé (≥32), refusé en prod (`APP_ENV/ENV`),
`len<32` rejeté. Reste : dev boot sur défaut public (assumé).
- #5/#6/A2/A3/A4 upload : ext whitelistée, `LimitReader` octets réels,
temp+`Rename`+`Fsync`, `0700/0600`, cleanup stale/orphelins. Tests OK.
- #7 batch : `Claim`/`MarkApplied` + `applied:i/INTERNAL` explicites.
Documenté non-transactionnel (vrai Tx reportée).
- #8 fuites : `classifySyncError` générique + log serveur. OK côté sync.
- #9 `Count` : `WHERE deleted_at IS NULL`, bootstrap recrée l'admin. OK.
- #10 migrations : `000007` sans `DELETE`, `000008 down` sans `::bigint`
crash, + `000011/12/13` saines. Up/down OK.
- #11 stubs : `folders/move/upload/move_test` supprimés, 0 réf. OK.
- #12 oracle : device inconnu → `401` identique + rate-limit 60/min/IP. OK.
- A1 dummy : random 32B/boot + guard `user==nil → 401` + caps Argon2. OK.
### Moyens : corrigé, 3 partiels assumés
- A6 `errors.Is`, A8 sémantiques (absent → no-op, étranger → `NOT_FOUND`
halt), A9 rejeu (`payload_hash` 000013 + `ErrInvalidPayload`), A10 users
guards, A11 jobs gardés, A12 path containment + lang whitelist, A13 OCR
(timeout 120s, 2MiB, 50 pages), A7/A16 contrat : tous OK.
- Partiels : `EnforceDeviceExists` opt-in **défaut `false`** (tokens à
device inconnu passent toujours par défaut) ; `NewID()` panic conservé
(migration appelants partielle) ; double pool `main.go` subsiste ;
`POST /devices` sans rate-limit (TODO assumé).
- Reste : `UpdateNameByID`/`TouchResource` non scopés encore appelés
(`TouchOwned`/`UpdateNameOwned` ajoutés, migration appelants reportée).
### Risques résiduels à trancher
1. Activer `EnforceDeviceExists` par défaut (casse tokens existants —
planifier rotation).
2. Vrai Tx `ApplyBatch` (fenêtre TOCTOU admise, couverte par idempotence).
3. Rate-limit `POST /devices` + test cycle dédié manquant.
### Addendum validation v2 (autres tâches finalisées)
`go build ./...` OK, `go test ./...` vert (12 packages, dont
`handlers 9.6s`, `repository 3.4s`, `service 9.9s`).
Nouveautés depuis v1, toutes validées :
- `handlers/store.go` : `writeError` défaut → `500 INTERNAL "internal error"`
générique + `log` serveur (plus de `err.Error()` brut) — clôt #8 côté
handlers.
- `handlers/sync.go` : `POST /sync/ops` borné (`MaxBytesReader` 1 MiB, max
100 ops/batch → 400 explicite) + `parseAfterMs` strict 64-bit
(garbage/négatif → 400, fini le repli silencieux vers full snapshot) —
clôt le gap « sync non borné ».
- `repository/devices.go` : `MarkUser` → `ErrNotFound` si 0 rows (fini le
no-op silencieux sur device fantôme ; la course `Exists→MarkUser` est
désormais distinguable). Résiduel mineur : `handlers/auth.go` mappe
encore cette erreur vers 500 au lieu de 401.
- Nouveaux tests : `handlers/ocr_test.go`, `handlers/sync_test.go`,
`repository/devices_test.go` — tous verts.
Restent ouverts : `EnforceDeviceExists=false` par défaut, vrai Tx
`ApplyBatch`, rate-limit `POST /devices`, test cycle dédié.
## Suite (2026-09-21, fin des restes — suite verte)
`go build ./...` OK, `go vet ./...` OK, `go test ./...` : 12 packages OK, 0 fail.
Nouveaux tests exécutés nominalement (`-run` ciblé) : `TestApplyBatchMoveIntoDescendantRejected`,
`TestDevicesRegisterRateLimited`, `TestSyncOpsBatchTooLargeRejected`,
`TestDevicesMarkUserUnknownDevice`, `TestIssueWithExpiryMatchesTokenExp`.
- **#8 fuite `writeError`** : défaut `500` → message générique `"internal error"`
+ `log.Printf` serveur (`handlers/store.go:20-33`). Plus aucun `err.Error()`
brut vers le client (sync déjà générique, `response.go` déjà enveloppe).
- **A7 `ExpiresAt`** : `pkg/auth.IssueWithExpiry` retourne le `exp` embarqué ;
`AuthLogin` l'expose tel quel (plus de `Now()+TTL` recalculé). `Issue`
conservée (délègue) → 0 appelant cassé. Test d'égalité à la seconde
(le token sérialise sans monotonique/sous-seconde).
- **`MarkUser`** : `RowsAffected == 0 → ErrNotFound`
(`repository/devices.go:36-42`) ; login mappe en **401 indistinguable**
(jamais de token pour device fantôme). Test repo ajouté.
- **`TouchOwned` migré** : les 4 `TouchResource` des paths share/revoke/link
→ `TouchOwned(ownerID, …)` (tous précédés de `ExistsOwner`). `UpdateNameByID`
**conservé volontairement** pour `update_metadata` (un editor non-owner peut
renommer — `UpdateNameOwned` rejetterait à tort ; garde d'accès juste avant
l'écriture). Commentaires `Deprecated`/inter-lots mis à jour.
- **Test cycle** : `TestApplyBatchMoveIntoDescendantRejected` (parent→enfant →
`INVALID_REQUEST`, parent toujours à la racine). Point 3 des risques soldé
côté cycle.
- **Rate-limit `POST /devices`** : 300/min/IP → 429 `RATE_LIMITED` + hook
`OnDevicesRateLimited` + `ResetDevicesRateLimit` (placé APRÈS validation :
l'invalide ne consomme pas le budget). Resets ajoutés aux helpers de test
(`files_test.go setup`, `auth_test.go setTestAuth`, `ocr_test.go setupOcr` —
ce dernier manquait et faisait échouer `TestOcrJobsScopedByOwner` en 429,
corrigé). Budget large assumé : anti-flood massif, WAF frontal en prod.
- **Cap `POST /sync/ops`** : `MaxBytesReader` 1 MiB + max 100 ops/batch → 400
`INVALID_REQUEST` (client = 20, test 25 ops existant compatible).
Test `TestSyncOpsBatchTooLargeRejected` (101 ops → 400).
### Reste assumé (inchangé, documenté)
- `EnforceDeviceExists` défaut `false` ; `NewID()` panic conservé
(`NewIDErr` dispo) ; double pool `main.go` (migrate-avant-open, un seul
vivant) ; vraie Tx `ApplyBatch` reportée (idempotence couvre la fenêtre).
+1 -1
View File
@@ -29,5 +29,5 @@ cd mobile-kotlin && ./gradlew :app:testDebugUnitTest
| Backend entry | `backend/cmd/server/main.go` — wiring gin + routes | | Backend entry | `backend/cmd/server/main.go` — wiring gin + routes |
| Sync outbox | `mobile-kotlin/.../features/sync/OutboxSyncWorker.kt` — worker WorkManager → `POST /sync/ops` | | Sync outbox | `mobile-kotlin/.../features/sync/OutboxSyncWorker.kt` — worker WorkManager → `POST /sync/ops` |
| SAF scan | `mobile-kotlin/.../features/sync/DeviceSync.kt` — two-pass walk SAF ↔ Room | | SAF scan | `mobile-kotlin/.../features/sync/DeviceSync.kt` — two-pass walk SAF ↔ Room |
| Room DB | `mobile-kotlin/.../data/local/AppDatabase.kt` — version 7, migrations, DAO | | Room DB | `mobile-kotlin/.../data/local/AppDatabase.kt` — version 16, migrations, DAO |
| API Retrofit | `mobile-kotlin/.../data/remote/ApiService.kt` — interface Retrofit (contrat client) | | API Retrofit | `mobile-kotlin/.../data/remote/ApiService.kt` — interface Retrofit (contrat client) |
-137
View File
@@ -1,137 +0,0 @@
# Découpage parallèle — Backend Kazier
Source : `FEEDBACK.md` (12 + A1-A16). But : 6 lots preneurs en parallèle, **zéro chevauchement de fichiers**.
Règle : chaque lot ne touche QUE ses fichiers. Si besoin transverse → note dans `Besoins inter-lots`, ne pas éditer hors lot.
Commande vérif par lot : `cd backend && go test ./...` (ou package ciblé). DB tests : `TEST_DATABASE_URL` si PG dispo, sinon skip OK.
---
## LOT 1 — AUTH critique (A1, #4, #12, A15-part)
**Fichiers exclusifs :**
- `backend/pkg/passwd/passwd.go`
- `backend/pkg/auth/auth.go`
- `backend/config/config.go`
- `backend/handlers/auth.go`
- `backend/handlers/middleware.go`
**Tâches :**
1. A1 : `dummyHash` aléatoire par boot (plus de `"kazier-constantime-dummy"` en dur). `AuthLogin` : early-return si `userErr != nil`, ne jamais toucher `user.ID` quand nil. Ajouter test : login user inconnu + password dummy → 401, pas 500.
2. #4 : `AUTH_SECRET` : refuser défaut `dev-secret-change-me` en prod (ex. `if ENV=prod && secret==défaut → Fatal`), exiger longueur ≥ 32, doc `.env.example`.
3. #12 : casser l'oracle : même code/délai que device existe ou non (vérifier device AVANT ou uniformiser 401). Ajouter rate-limit basique ou hook (même no-op + TODO).
4. A15-part : `Verify` : rejeter `userID/deviceID` non `^[0-9a-f]{32}$`. Middleware : option `EnforceDeviceExists` (défaut off, documenté) ou au moins log.
**Ne pas toucher :** `handlers/devices.go` (LOT 6), `repository/*` (LOT 4).
**Acceptance :** `go test ./pkg/passwd/... ./pkg/auth/... ./handlers/...` OK + test regression A1.
---
## LOT 2 — UPLOAD safe (A2, A3, A4, #5, #6, A16-part)
**Fichiers exclusifs :**
- `backend/service/resources.go`
- `backend/handlers/files.go`
**Tâches :**
1. #5 : sanit `extension` : `[a-z0-9]{1,10}` lowercase, sinon `""` ou `bin`. `destPath` sans `ext` si vide (pas de `id.`). Rejeter `/`, `..`, très long.
2. A2 : service : `io.LimitReader(src, MaxFileSize+1)` + vérifier octets écrits, retourner `ErrFileTooLarge` même si header ment.
3. A3 : écriture atomique : temp `destDir/.tmp-<id>` + `Fsync` + `Rename`. Pas d'overwrite direct.
4. #6 : au `UpdatePhysical` : lister `Glob(id.*)` ancien, `Remove` les autres ext. Sur `Insert` fail → `Remove(destPath)`. Sur `GetFile` fail après insert → tenter cleanup, au moins log.
5. A4 : `MkdirAll 0700`, fichier `0600` (`OpenFile` + `Chmod`). Vérifier umask.
6. A16-part : `file.Filename` → `name` : `TrimSpace`, cap 255, rejeter vide/`/`/`\n`. `Content-Type` : whitelist ou fallback `application/octet-stream`. `intParam/page/pageSize` : cap + 400 si négatif (pas fallback silencieux), `q` : `MaxLen 200`.
**Acceptance :** tests service upload : header menteur, ext vide/malicieuse, re-upload change ext → un seul fichier physique, perms 0600/0700.
---
## LOT 3 — SYNC core (#3, #7, A8, A9)
**Fichiers exclusifs :**
- `backend/service/sync.go`
- `backend/repository/operations.go`
- `backend/repository/shares.go`
**Tâches :**
1. #7 : rendre `ApplyBatch` atomique par op : `SELECT ... FOR UPDATE` ou transaction `Applied→apply→Record`. `Record` fail → retourner `applied:i` explicite, pas 500 nu.
2. #3 : `CreateLink` idempotent : `ON CONFLICT (id) DO NOTHING` + vérifier owner identique, sinon `NAME_CONFLICT`.
3. A9 : stocker `payload_hash (sha256)` dans `operations`, au replay même `(device,op)` comparer hash : différent → `INVALID_REQUEST` (pas skip silencieux). Migration `000011`.
4. A8 : uniformiser sémantiques : `update_metadata` absent → `NOT_FOUND` halt (pas no-op applied) ; `move/delete` non-owned → `NOT_FOUND` (pas applied silencieux) ; documenter choix. `create` : `ExistsOwner` + `Insert` en transaction ou `ON CONFLICT DO NOTHING` + check owner.
5. `classifySyncError` : ne plus fuir `err.Error()` brut (#8-part) : messages génériques + log interne.
**Ne pas toucher :** `repository/resources.go` (LOT 4) — si besoin, exposer interface, pas d'édit direct.
**Acceptance :** tests `service/sync_test.go` : replay même op, replay payload muté, create_link rejoué, move/delete grantee.
---
## LOT 4 — DATA ownership + migrations (#9, #10, A10, + parent-check)
**Fichiers exclusifs :**
- `backend/repository/users.go`
- `backend/repository/resources.go`
- `backend/repository/devices.go`
- `backend/service/bootstrap.go`
- `backend/db/migrations/*`
- `backend/db/db.go` (lecture seule sauf si besoin migration)
**Tâches :**
1. #9+A10 : `Count()` → `WHERE deleted_at IS NULL`. `UpdatePassword/MarkDeleted/GetByID` : ajouter `AND deleted_at IS NULL` + check `RowsAffected` → `ErrNotFound` si 0.
2. #10 : `000007` : supprimer `DELETE FROM resources` (backfill `owner_id` via user admin ou colonne nullable + migration douce). `000008 down` : down sans `::bigint` (ex. recréer colonne bigint + drop text, ou marquer irréversible avec message clair).
3. Parent-check atomique : `InsertFolder/InsertFile/MoveResource` : `INSERT ... SELECT` ou transaction `SELECT parent FOR SHARE → INSERT`, FK 500 → mapper `NOT_FOUND`.
4. `TouchResource/UpdateNameByID` : ajouter variantes scopées `TouchOwned(ownerID,...)`, `UpdateNameOwned(...)`, laisser anciennes en `deprecated` (LOT 3 migrera ensuite).
5. `NewID()` (A5) : retourner `(string,error)` OU `MustNewID` + `NewIDErr`. Choisir une signature, mettre à jour appelants **uniquement dans ces fichiers**.
**Acceptance :** `go test ./repository/... ./service/... ./db/...` + test soft-deleted login/bootstrap.
---
## LOT 5 — OCR + INFRA (A11, A12-part, A13, A14, #11)
**Fichiers exclusifs :**
- `backend/service/ocr.go`
- `backend/repository/ocr_jobs.go`
- `backend/ocr/*`
- `backend/cmd/server/main.go`
- `backend/service/services.go`, `move.go`, `upload.go`, `folders.go` (suppression)
**Tâches :**
1. #11 : supprimer les 4 stubs `UserCan*` toujours-true.
2. A11 : transitions gardées : `Complete/ Fail WHERE status='processing'`, `TouchProcessing WHERE status='queued'`, check `RowsAffected`. `ResetStaleProcessing` sur horloge DB (`now() - interval`), inclure `started_at IS NULL`. Ajouter index `(status,created_at)` (migration `000012` — coordonner nom avec LOT 4 pour éviter collision : LOT 5 prend `000012`, LOT 4 prend `000011`, LOT 3 payload_hash prend `000013`).
3. A13 : `Fail` avec `err`, `Complete` vérifie `UpdateOcrText RowsAffected`, sinon `Fail`. `tesseract.go` : `context.WithTimeout` par job (ex. 120s), `LimitReader` stdout/stderr (ex. 2MB), cap pages PDF (ex. 50) + erreur si tronqué, pas `continue` silencieux.
4. A12-part : `physicalPath` : `Lstat`, `IsRegular`, `EvalSymlinks` ∈ `UPLOAD_DIR`. `OCR_LANG` : whitelist `^[a-z+]{2,20}$`.
5. A14 : `main.go` : un seul pool (réutiliser `conn` pour migrate), `defer conn.Close()`, worker OCR avec `WaitGroup` + shutdown 5s documenté. Bootstrap : retry duplicate `username_normalized` ou `ON CONFLICT DO NOTHING`.
**Acceptance :** `go test ./ocr/... ./service/... ./repository/...` + test double-complete, stale requeue.
---
## LOT 6 — CONTRACT + DEVICE (A6, A7, §1 route, devices, secret-doc)
**Fichiers exclusifs :**
- `backend/handlers/router.go`
- `backend/handlers/share_links.go`
- `backend/handlers/sync.go`
- `backend/handlers/devices.go`
- `backend/handlers/health.go` (tests seulement si besoin)
- `backend/cmd/server/router_test.go`
- `backend/pkg/api/response.go` (messages génériques seulement)
**Tâches :**
1. §1 : réordonner `GET /files/folders` avant `GET /files/:id` + test `folders→200`, `:id=folders→404` (verrouille, même si Gin priorise statique).
2. A6 : `ShareLinkGet` : `errors.Is(err, ErrNotFound)`.
3. A7 : `ExpiresAt` : utiliser `exp` du token (retourner `Auth` ou parser), pas `Now()+TTL`. `TOKEN_ERROR` → `INTERNAL`. 32-hex malformé → `400 INVALID_REQUEST` partout (aligner `files.go` sur `devices.go`). `intParam/after` : 400 si garbage/négatif (pas fallback 0), `Atoi` 64-bit pour epoch-ms. `Bearer` : accepter `bearer` case-insensitive (option).
4. Devices : `POST /devices` : rate-limit/TODO + doc. `MarkUser` : check `RowsAffected` (device supprimé → 404).
5. `response.go` : messages génériques côté client, détail en log serveur (#8-part lot 6).
**Acceptance :** `router_test.go` étendu + tests handlers 400/404 cohérents.
---
## Ordre et dépendances
- Démarrage immédiat possible : LOT 1, LOT 2, LOT 5, LOT 6 (aucune dépendance mutuelle).
- LOT 3 et LOT 4 se touchent via `repository/resources.go` : LOT 4 seul l'édite. LOT 3 utilise l'interface existante, migrera vers `*Owned` au tour suivant.
- Migrations : LOT 4 = `000011`, LOT 5 = `000012`, LOT 3 = `000013`. Ne pas réutiliser un numéro.
- `NewID()` signature (LOT 4) : prévenir LOT 2/LOT 3 après merge, pas avant.
## Besoins inter-lots (ne pas éditer, juste signaler)
- LOT 3 → LOT 4 : besoin `TouchOwned/UpdateNameOwned`, `INSERT ... SELECT` parent.
- LOT 5 → LOT 2 : `physicalPath` safe partagé après merge LOT 2.
- Tous → LOT 6 : après uniformisation 400/404, aligner messages d'erreur.
+126
View File
@@ -0,0 +1,126 @@
# Kazier V3 — « Le classeur qui comprend »
Statut : **livrée en 1.2.0** (2026-09-26). V1 (1.0.0, socle local-first + partage) et V2 (1.1.0, multi-device : upload/download, placements, rétention, groupes) sont livrées. Ce document reste le contrat produit + plan d'exécution de la V3 (toutes slices S1–S7 livrées).
## 1. Positionnement (acté)
- **Tout fichier est un document potentiel, y compris une photo.** Une image (scan, photo de papier, photo tout court) suit le même pipeline : OCR quand il y a du texte, faits génériques, FTS, relations. En revanche **aucune analyse biométrique ou sémantique d'image** : pas de visages, pas de lieux, pas d'événements, pas de clustering de personnes. Si une photo contient du texte (affiche, facture photographiée), on l'exploite ; sinon elle reste un fichier comme un autre (nom, dossier, favori, partage).
- **Tous les documents comptent pareil.** Pas de top-5 types prioritaires. Extraction **générique d'abord** (dates, montants, émetteurs, références), typage (`facture`, `contrat`…) en **bonus humble** : suggestion corrigeable, jamais gate, jamais pénalisant.
- **Humble par design.** L'extraction se trompe (~20% au début). Donc : chaque fait porte une `confidence`, l'UI affiche le douteux en « suggéré », la recherche **déclasse mais n'exclut jamais** sur un fait douteux, et tout est corrigeable en un tap.
- **Échéance = facette, pas alerte.** Trop bruitée pour notifier (faux « expiré » dangereux). Filtre + tri uniquement. Alertes = V4 éventuelle, sur preuve de fiabilité via feedback.
- **100% self-hosté / local-first.** Aucun appel IA externe. Règles FR + petits modèles CPU côté serveur, cache Room offline, workers async jamais bloquants (même pattern que `Ocr.Run`).
- **Pas de LLM génératif en V3.** On extrait des faits vérifiables, on ne rédige rien. Moins d'hallucinations, moins de GPU, plus de confiance famille.
## 2. Les 5 piliers (cœur, scope 6–8 semaines)
| # | Pilier | Promesse | Réutilise |
|---|---|---|---|
| P1 | Filet anti-perte | Corbeille 30j + versions N=3 | `deleted_at` soft-delete, `UPLOAD_DIR/<user>/<resource>.<ext>`, overwrite ciblée V2 |
| P2 | Extract générique | Faits universels + type suggéré, corrigés depuis la fiche document | Pipeline `upload ciblé → Tesseract → resources.ocr_text → GET /files/:id/ocr`, gate `processed` |
| P3 | Recherche | FTS nom+ocr+faits, facettes, offline | `FileDao.searchWithFilters` (LIKE+accents), `GET /files/search` serveur |
| P4 | Relations doc | `same_scan` (sûr) + doublons/versions/même-émetteur (invalidables), collections virtuelles | `scan_sessions`+`scan_pages`, `content_hash` (V2.md), versions P1 |
| P5 | Partage sobre | Cercles (groupes V2-6), liens à expiration par défaut, révocation tokens, quota/3-2-1 visible | Snapshot permissions + TTL 24h, `share`/`create_link`, `PATCH /users/me/password` |
## 2bis. Plan A — cohérence obligatoire (inclus dans la V3, pas du scope en plus)
Sans ces 4 items, les piliers grincent. Ils sont petits et intégrés aux slices S1–S6 :
- **A1 Appareils connectés** : exposer `storage_locations` (existe depuis V2, migration `000015`) en lecture `GET /devices` + `DELETE /devices/:id` (révocation = bump `token_version` ciblé ou suppression ligne ; le device révoqué retombe en 401 → re-login refusé `INVALID_DEVICE_ID`). Écran Réglages « Appareils » : voir / révoquer un téléphone perdu. Grosse valeur famille, ~1 endpoint + 1 écran.
- **A2 Quota enforcement** : `/usage` (P5) n'est que de l'affichage. Ajouter `users.storage_quota_bytes` (défaut 10 Go, cf. V2.md §3.1) + garde-fou à l'upload (`413 QUOTA_EXCEEDED`) + à l'overwrite versionnée. Migration `000023_quota`. Sans ça, un foyer remplit le disque.
- **A3 Corbeille cohérente des deux côtés** : règle purge serveur (cron au boot + passe quotidienne : `trashed_at < NOW()-30j` → purge dure) **+** miroir mobile (`trashed_at` Room, filtre global `exists=1 AND trashed_at IS NULL`, écran Corbeille). Le walk SAF doit ignorer les trashés (garde `hasPendingTrash`, même pattern que FEEDBACK M5) sinon ils ressuscitent. Fait partie de S1, pas une option.
- **A4 Conflits rename transparents** : `update_metadata` concurrent (2 devices renomment) = last-writer-wins silencieux aujourd'hui. Minimum V3 : comparer `updated_at` (perdant = op arrivée sur `updated_at` plus récent que son `base_updated_at` → appliquée quand même mais flag `conflict` remonté dans la réponse `POST /sync/ops` + badge UI « renommé ailleurs » via snapshot). Pas de CRDT, juste de la transparence. Payload `update_metadata` étendu : `{ name?, baseUpdatedAt? }`.
## 2ter. Plan B — quick wins produit (inclus : B1, B2, B4 ; B3/B5 en stretch)
- **B1 Import « classeur » unifié** : un seul point d'entrée « Ajouter un papier » (scan / photo / PDF / fichier) + file d'attente d'import visible (compteur `unprocessed`, déjà en Room). Aujourd'hui scan + upload + PDF builder sont 3 chemins séparés — les unifier en UX, zéro backend nouveau. Inclus (S6).
- **B2 Doublons visibles + action** : `duplicate_of` (P4, hash) exposé en écran « Doublons (240 Mo récupérables) » + action « garder un seul » (= trash les autres, même op `trash_resource`). Les familles adorent. Inclus (S5).
- **B3 Impression / export PDF** : ouvrir le PDF builder existant aux docs déjà stockés (pas qu'au multi-select) + `ACTION_SEND` / impression système. Stretch S7 (pur mobile, pas de backend).
- **B4 Accessibilité + i18n** : labels TalkBack sur review/chips/facettes, contrastes, chaînes FR/EN des nouveaux écrans dès la slice (pas de rattrapage). Inclus, transverse à chaque slice.
- **B5 Onboarding foyer** : écran « Crée ton cercle Famille » au premier login + import guidé des 3 premiers papiers (deep-link vers B1 + création groupe V2-6 pré-rempli). Sans ça, les cercles P5 restent vides. Stretch S6 si le temps manque (1 écran + 1 CTA, pas de backend).
## 2quater. Plan C — dette V2.md : solder ou enterrer (décisions actées)
- **C1 `retention_policies` serveur (V2.md §3.6) : ENTERRÉ.** La rétention V2 mobile (`RetentionStore` + `RetentionWorker`) fait le job ; une politique serveur ajouterait un 2e cerveau en conflit avec le walk local-first. Documenter dans `docs/api-v1.md` : « la rétention est une affaire locale ».
- **C2 `sync_queue` serveur (V2.md §3.7) : ENTERRÉ.** L'outbox client (`pending_operations` + batch 20 + dead-letter) + workers WM couvrent le besoin. Ne pas rouvrir.
- **C3 Backup 3-2-1 réel : EXPORT, pas second serveur.** `role='backup'` reste un modèle, pas une infra. Minimum V3 : bouton « Exporter tout » (zip + manifest `resource_id, name, hash, facts`) depuis Réglages/Stockage — testé, restaurable, chiffré par le mot de passe (zip AES). Stretch S7, à arbitrer contre les embeddings : **l'export gagne** (vrai 3-2-1 perçu, zéro GPU).
## 3. Backend — plan fichier par fichier
### 3.1 Migrations (`backend/db/migrations/`, une par palier, up+down + `migrations_test.go`)
- `000017_trash` : rien à créer — ajouter index partiel `idx_resources_deleted_at ON resources(deleted_at) WHERE deleted_at IS NOT NULL` + colonne `trashed_at TIMESTAMPTZ` (NULL = vivant ; purge = `trashed_at < NOW()-30j`). Le `DELETE` actuel devient trash (soft), pas de breaking change API.
- `000018_versions` : table `resource_versions (id 32-hex PK, resource_id FK CASCADE, version_no INT, size_bytes BIGINT, content_hash TEXT, stored_path TEXT, created_at)` + `UNIQUE(resource_id, version_no)`. À chaque overwrite d'octets (upload ciblé), la copie précédente est poussée en version (garder N=3, purger la plus vieille).
- `000019_facts` : table `resource_facts (id 32-hex PK, resource_id FK CASCADE, fact_type TEXT CHECK IN ('date','due_date','period','amount','issuer','reference','doc_type'), value_text TEXT, value_num NUMERIC NULL, value_date DATE NULL, confidence REAL CHECK 0..1, origin TEXT CHECK IN ('auto','user'), created_at, updated_at)` + index `(resource_id)`, `(fact_type, value_text)`. `doc_type` n'est qu'un fait comme un autre (suggestion, pas statut).
- `000020_search_fts` (livré S4) : colonne `search_tsv TSVECTOR` générée (`name + ocr_text`, `french`) + index GIN ; faits joints à la requête (rang, jamais d'exclusion).
- `000021_links` (S5, livré) : table `resource_links (id 32-hex PK, from_id/to_id canoniques, link_type IN (same_scan, duplicate_of, same_issuer, same_reference) — pas de `version_of`, CHECK from != to, UNIQUE trio)` + `resources.scan_session_id` (session opaque du create outbox). `version_of` non matérialisé (versions DANS la ressource).
- `000022_token_version` (S6) : `ALTER TABLE users ADD COLUMN token_version INT NOT NULL DEFAULT 0` — `PATCH /users/me/password` bump ; claim paseto `tv`, middleware `RequireAuth` rejette `tv != users.token_version` (lève la limite V1 « tokens non révoqués »).
- `000023_quota` (A2, S6) : `ALTER TABLE users ADD COLUMN storage_quota_bytes BIGINT NOT NULL DEFAULT 10737418240` (10 Go, V2.md §3.1) + vue/fonction `user_used_bytes(user_id)` (somme `size_bytes`hors trash). Check à l'upload et à l'overwrite versionnée → `413 QUOTA_EXCEEDED` (nouveau code §7).
> Ordre imposé par golang-migrate (montée stricte, pas de trous) : FTS a pris `000020` en S4, décalant links→`000021` et token→`000022`.
### 3.2 Extract — nouveau worker (miroir `service/ocr.go`, `cmd/server/main.go`)
- Nouveau `backend/extract/rules.go` : pur package, **testable sans PG** — entrée `text string`, sortie `[]Fact{Type, ValueText/Num/Date, Confidence}`. Règles FR : dates (`12/03/2026`, `mars 2026`, `échéance ..`), montants (`1 234,56 €`, `EUR`), raisons sociales (ligne en capitales + SIRET/SIREN voisin), références (`n°`, `facture n°`, `contrat`, IBAN masqué → on ne stocke que les 4 derniers chiffres).
- Nouveau `backend/service/extract.go` : struct `Extract{Repository}` + `Run(ctx)` — même squelette que `Ocr.Run` (poll file, `FOR UPDATE SKIP LOCKED`, `QueuePollInterval`, `ResetStale` au boot). Déclencheur : après chaque OCR `done` avec texte non vide (appel direct `Extract.Enqueue/Process` depuis `Ocr.process`, pas de nouvelle file PG — une colonne `extract_status` sur `ocr_jobs` ou simple appel synchrone borné suffit en V3).
- `backend/repository/facts.go` : `UpsertAuto(resourceID, facts)` (remplace les `origin='auto'`, ne touche jamais aux `origin='user'`), `Correct(resourceID, facts)` (écrit `origin='user'`, confidence 1.0), `ListForResource`, `SearchFacets(...)`.
- `backend/repository/links.go` : `EnsureAuto` (idempotent, upsert par `(from,to,type)`), `SetUserVerdict` (confirme/invalide → `created_by='user'`, confidence 0/1), `ListForResource`. Règles auto V3 : `same_scan` (déterministe depuis `scan_sessions` — en fait côté mobile, voir §4, serveur : `duplicate_of` via `content_hash` égal, `version_of` via `resource_versions`, `same_issuer` via facts `issuer` normalisé identique + confidence = min des deux facts).
- `backend/service/resources.go` : trash/restore/purge (`Trash` = set `trashed_at`, `Restore` = NULL, `Purge` = hard delete + versions + faits + liens + fichier physique) ; overwrite d'octets → pousser l'ancienne copie en `resource_versions` avant écriture.
- `backend/service/sync.go` : nouvelles ops outbox **`trash_resource` / `restore_resource` / `purge_resource` / `correct_facts`** (même enveloppe §6.1, `operation_id` 32-hex, idempotence `(device_id, operation_id)`, arrêt au premier échec non-idempotent). `delete_resource` legacy → mappé vers `trash_resource` (pas de break client existant). `correct_facts` porte `[{fact_type, value, confidence}]`, applique `Correct` (writer = user, écrase l'auto).
- `backend/handlers/` : `GET /trash` (liste `trashed`, paginé, même enveloppe `{data,meta}`), `POST /files/:id/restore`, `DELETE /files/:id?mode=purge` (défaut trash ; `purge` = définitif), `GET /files/:id/versions` + `POST /files/:id/versions/:n/restore`, `GET /files/:id/facts` + `PATCH /files/:id/facts` (correction directe, même sémantique que `correct_facts`), `GET /files/:id/relations` + `POST /files/:id/relations/verdict` (livrés S5 — `/links` étant pris par les liens de partage), `GET /duplicates` (livré S5 B2), `GET /users/me/usage` (quota + copies 3-2-1 : `used_bytes`, `quota_bytes`, `copies`, `offsite_ok`), `GET /devices` + `DELETE /devices/:id` (A1, lecture `storage_locations` + révocation), `GET /export` (C3, zip + manifest, streamé). Tous scopés `viewer+` lecture / `owner` mutation sauf `correct_facts` (`editor+`, comme `update_metadata`).
- `backend/handlers/router.go` + `cmd/server/router_test.go` : enregistrer les routes (le test de contrat miroir du client doit rester vert).
- `docs/api-v1.md` §6.1/§7 : documenter les 4 ops + codes (`TRASHED` vs `NOT_FOUND` — une ressource trashée reste `NOT_FOUND` en lecture normale, visible seulement via `/trash`).
### 3.3 Recherche serveur
- `repository/resources.go` `SearchFilesVisible` : brancher `search_tsv @@ plainto_tsquery('french', q)` en OR avec le `LIKE` existant (compat), rank `ts_rank` + bonus si match facts (`issuer`, `reference`). Jamais d'exclusion sur fait basse-confiance : `confidence < 0.5` → pondération /2, pas filtre.
- Facettes : `GET /files/search?q=&issuer=&from=&to=&min_amount=&max_amount=&doc_type=` — filtres SQL sur `resource_facts` (jointure, `origin` indifférent, `doc_type` = suggestion acceptée comme filtre mais affichée « suggéré » si `origin='auto'`).
## 4. Mobile — plan fichier par fichier
### 4.1 Room (v19 → v20 faits, v21 FTS — voir S3/S4, `app/schemas/` exporté, tests `MigrationXToYTest`)
- v19 (S1, livré) : `trashed_at` sur files + folders.
- v20 (S3, livré) : `resource_facts (id, resource_id, fact_type, value_text, value_num, value_date, confidence, origin, updated_at)` + `FactsDao` (remplacement en bloc au sync, corrections `user` poussées en outbox).
- v22 (S5, livré) : `resource_links` (miroir `GET /relations`, remplacement en bloc, verdicts REST directs) + `LinksDao` + `collections` (requêtes sauvegardées locales, jamais syncées) + `CollectionDao`. `is_favorite` reporté (non bloquant, S6+ si besoin).
- v21 (S4) : FTS4 `files_fts (name, ocr_text, facts_text)` + triggers sync + requête `searchDocuments(query, facets)` remplaçant `searchWithFilters` pour les docs (garder l'ancien pour dossiers). `facts_text` = concat des `value_text` — reconstruit à chaque sync facts.
- `OutboxRepository.kt` : `enqueueTrash/restore/purge`, `enqueueCorrectFacts` (payload `[{fact_type, value}]`, `GenerateId` 32-hex, même transaction Room que la mutation parente — contrat outbox atomique inchangé). `delete_resource` existant → renommé en trash côté appelants (`FileDeleter`, `FolderDeleter`).
### 4.2 Review = moment de vérité (zéro écran en plus)
- `OcrRepository.syncFromServer` : après `ocr_text`, rapatrier `GET /files/:id/facts` → Room (même pattern `syncFromServer`, poll existant réutilisé).
- Fiche document (livré S3 — pas le review : le deck ne contient que des fichiers jamais OCR-és, sans faits) : fiche « Ce qu'on a compris » (`FactsBottomSheet`, bouton viewer si `processed`) — chips `Émetteur: EDF • 84,20 € • Échéance: 12/04 (suggéré)`, confiance < 0.5 grisée, user gagne par type à l'affichage, édition par type (texte/nombre/date ISO) → `enqueueCorrectFacts` dans la **même transaction** que l'écriture Room optimiste, reset « rétablir auto » (jeu vide poussé).
- Fiche document : section « Voir aussi » (`LinksDao` → `same_scan` d'abord avec badge « sûr », puis autres avec bouton invalider) + section « Faits » (grisé si `confidence < 0.5`).
### 4.3 Relations `same_scan` (déterministe, local)
- `ScanExport.kt` : à l'export multi-pages, écrire les liens `same_scan` entre les `resource_id` de la session (même transaction que les `create_resource`). Confiance 1.0, `created_by='user'` (acte volontaire). Poussés via `correct_facts`-like ? Non — nouvelle op `link_pages` ou piggyback sur `create_resource` payload (préféré : champ `scanSessionId` dans le payload `create_resource`, le serveur en déduit `same_scan` — **zéro nouvelle op**).
- Collections virtuelles : table locale `collections + collection_members` (requêtes sauvées sur facts, ex. « Impôts 2026 » = `doc_type suggéré:impôt + period:2026`) — pur local en V3, pas de sync (un device, pas de conflit). Sync serveur = V4.
### 4.4 Recherche + facettes UI
- Barre unique : texte + chips facettes (`émetteur`, `période`, `montant`, `type suggéré`). Requête Room FTS offline ; si réseau, `GET /files/search` enrichit (même ranking affiché, source badgée « serveur »).
- OutboxSyncWorker : après drain, enchaîner `FactsSync` (comme `OcrAutoWorker` aujourd'hui) — pas de nouveau worker WM, simple étape dans le worker existant.
### 4.5 Partage sobre + confiance
- Sheet existant : expiration lien **7j par défaut** (aujourd'hui `null`), badge « suggéré » sur `doc_type`, section copies déjà là (placements V2) + ligne quota/3-2-1 (`GET /users/me/usage` → Réglages/Stockage existant).
- `SessionManager` : `tv` claim (voir §3.1 `token_version`) — changement de password → autres devices 401 → re-login silencieux existant (aucun code nouveau, juste le claim).
## 5. Ordre d'exécution (7–9 semaines, chaque ligne = shippable)
1. **S1 — Filet + A3** (livré : BE `000017/000018` + trash/restore/purge + cron purge 30j + mobile v19 + `FileDeleter` → trash + gardes walk + écran Corbeille) — done quand : supprimer → restaure depuis un 2e device, le walk ne ressuscite pas.
2. **S2 — Extract générique** (livré : `extract/rules.go` + `service/extract.go` + `000019` + `UpsertAuto` + `GET /files/:id/facts`) — done quand : un scan EDF propose émetteur/montant/échéance.
3. **S3 — Fiche + correction** (livré : `PATCH /files/:id/facts` + op `correct_facts` editor+ + Room v20 facts + fiche viewer + `FactsRepository` + B4 a11y fiche) — done quand : corriger en un tap converge serveur ↔ 2e device.
4. **S4 — Recherche** (livré : `000020` FTS + facettes serveur + Room FTS v21 + UI filtres + B4 a11y) — done quand : « facture edf mars » trouve `scan_042.pdf` offline ET online.
5. **S5 — Relations + B2** (livré : `000021` links + doublons SHA-256 + same_scan outbox + `GET /relations` + verdict + `GET /duplicates` + Room v22 + « Voir aussi » + Doublons + collections locales) — done quand : fiche CNI → verso + doublon listés, invalidables ; doublons chiffrés en Mo récupérables.
6. **S6 — Partage sobre + A1/A2/A4 + B1 (+B5 si temps)** (livré : expiration liens 7j défaut + `000022` token_version + `000023` quota idempotente + `413 QUOTA_EXCEEDED` + `GET /devices` + `DELETE /devices/:id` + `EnforceDeviceExists` prod + écran Appareils + quota/usage + `update_metadata{baseUpdatedAt}` + `conflicts[]` + pipeline mobile + import « classeur » unifié + onboarding cercle Famille) — done quand : lien RIB expiré → `NOT_FOUND`, password changé → autres devices re-logués, device perdu révoqué, quota plein → 413 propre, rename concurrent → badge « renommé ailleurs ».
7. **S7 — Preview + export** (livré : `000024` previews + `GET /files/:id/preview` JPEG 512 — images pur Go, PDF via `pdftoppm` + poppler, `NO_PREVIEW` sinon — + vignettes distantes mobile + `POST /export` zip AES + manifest + partage ACTION_SEND + release 1.2.0). Impression papier reportée V4 (pas de dep print).
## 6. Tests (mêmes harnais, pas de nouveau framework)
- BE : `dbtest` + `go test ./...` — `extract/rules_test.go` (corpus FR : factures, bulletins, courriers, cas limites montants/dates), tests repo `facts/links` (upsert auto n'écrase pas user, recherche ne filtre pas sur low-confidence), tests handlers (trash/restore/purge, versions, facts, links, usage, devices, export, quota 413, conflit rename), `router_test.go` vert.
- Mobile : `:app:testDebugUnitTest` (Robolectric + Room in-memory) — `Migration18To19/19To20Test`, `FactsSyncTest` (round-trip `correct_facts`), `SearchFtsTest` (accents, `%`/`_` échappés, facettes), `SameScanTest` (export multi-pages → liens), `TrashWalkTest` (walk n ressuscite pas les trashés, miroir FEEDBACK M5), `DuplicatesTest`, `QuotaBadgeTest`.
## 7. Non-goals V3 (actés, basculables V4)
Alertes d'échéance, résumés/chat LLM, embeddings sémantiques (déscopés au profit de C3 export — tables `facts`/`links` déjà prêtes à les accueillir en V4), analyse d'image biométrique/sémantique (visages, lieux, événements, clustering personnes — **hors vision par principe**, les photos restent des documents image), OCR on-device, transcodage vidéo, E2EE dédiée (les facts/liens héritent des perms `viewer+` comme `ocr_text` — pas de nouveau modèle de droits), sync des collections, client desktop/web, fédération, `retention_policies` serveur (C1 enterré : rétention = affaire locale), `sync_queue` serveur (C2 enterré : l'outbox client fait le job).
+1 -1
View File
@@ -1 +1 @@
0.1.0 1.2.0
+2 -1
View File
@@ -8,7 +8,8 @@ MAX_FILE_SIZE_MB=50
OCR_LANG=fra+eng OCR_LANG=fra+eng
# Sécurité — à changer en production (jamais commité) # 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 admin (créé UNIQUEMENT si la table users est vide). Obligatoires au
# premier démarrage ; ignorés ensuite (l'env n'écrase jamais un compte). # premier démarrage ; ignorés ensuite (l'env n'écrase jamais un compte).
+4 -2
View File
@@ -17,14 +17,16 @@ RUN CGO_ENABLED=0 GOOS=linux go build \
-o /out/kazier-server \ -o /out/kazier-server \
./cmd/server/main.go ./cmd/server/main.go
# --- runtime: mince, Tesseract (fra+eng) embarqué pour l'OCR --- # --- runtime: mince, Tesseract (fra+eng) embarqué pour l'OCR + poppler
# (pdftoppm) pour les vignettes PDF page 1 (V3 S7, best-effort) ---
FROM alpine:3.20 FROM alpine:3.20
RUN apk add --no-cache \ RUN apk add --no-cache \
ca-certificates \ ca-certificates \
tzdata \ tzdata \
tesseract-ocr \ tesseract-ocr \
tesseract-ocr-data-eng \ tesseract-ocr-data-eng \
tesseract-ocr-data-fra tesseract-ocr-data-fra \
poppler-utils
WORKDIR /app WORKDIR /app
+66
View File
@@ -61,6 +61,9 @@ func main() {
log.Fatalln(err) log.Fatalln(err)
} }
handlers.Auth = authManager handlers.Auth = authManager
// V3 S6 A1 : les tokens d'un device révoqué (ligne `devices` supprimée)
// sont rejetés en 401 — révocation réelle, pas décorative.
handlers.EnforceDeviceExists = true
repo := repository.NewRepository(conn) repo := repository.NewRepository(conn)
@@ -87,6 +90,28 @@ func main() {
) )
handlers.Ocr = service.NewOcr(repo, cfg.UploadDir, cfg.OcrLang, ocr.NewTesseract()) handlers.Ocr = service.NewOcr(repo, cfg.UploadDir, cfg.OcrLang, ocr.NewTesseract())
// V3 S2 : faits génériques — chaque texte OCR extrait alimente
// `resource_facts` (origin='auto'). Enrichissement best-effort : un
// échec d'extract ne fait jamais échouer le job OCR.
extractSvc := service.NewExtract(repo)
handlers.Ocr.OnText = func(userID, resourceID, text string) {
if err := extractSvc.ProcessText(userID, resourceID, text); err != nil {
log.Printf("extract: %s: %v", resourceID, err)
}
}
// V3 S5 : backfill des hashes (uploads d'avant la V3) — doublons.
go func() {
n, err := handlers.Store.BackfillHashes(200)
if err != nil {
log.Printf("content backfill hashes: %v", err)
return
}
if n > 0 {
log.Printf("content backfill hashes: %d fichiers", n)
}
}()
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop() defer stop()
@@ -102,6 +127,47 @@ func main() {
}() }()
log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers) log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers)
// V3 S2 : backfill extract (une passe bornée au boot — les ressources
// avec ocr_text mais sans faits auto, ex. OCR d'avant la V3).
go func() {
n, err := extractSvc.Backfill(200)
if err != nil {
log.Printf("extract backfill: %v", err)
return
}
if n > 0 {
log.Printf("extract backfill: %d ressources enrichies", n)
}
}()
// V3 corbeille : passe de purge (trash > TrashRetention) au boot puis
// toutes les heures. Best-effort : une passe ratée sera rejouée à la
// suivante, jamais de crash serveur sur une erreur de purge.
go func() {
purge := func() {
n, err := handlers.Store.PurgeExpiredTrash(service.TrashRetention)
if err != nil {
log.Printf("purge corbeille: %v", err)
return
}
if n > 0 {
log.Printf("purge corbeille: %d ressources détruites", n)
}
}
purge()
ticker := time.NewTicker(time.Hour)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
purge()
}
}
}()
log.Printf("purge corbeille démarrée (rétention %s)", service.TrashRetention)
srv := &http.Server{ srv := &http.Server{
Addr: fmt.Sprintf(":%d", cfg.Port), Addr: fmt.Sprintf(":%d", cfg.Port),
Handler: newRouter(), Handler: newRouter(),
+26
View File
@@ -17,11 +17,37 @@ var expectedRoutes = []string{
"GET /api/v1/files/folders", "GET /api/v1/files/folders",
"GET /api/v1/files/:id", "GET /api/v1/files/:id",
"GET /api/v1/files/:id/ocr", "GET /api/v1/files/:id/ocr",
"GET /api/v1/files/:id/facts",
"PATCH /api/v1/files/:id/facts",
"GET /api/v1/files/:id/content",
"GET /api/v1/files/:id/preview",
"GET /api/v1/files/:id/shares",
"GET /api/v1/files/:id/links",
"GET /api/v1/files/:id/placements",
"GET /api/v1/files/:id/versions",
"GET /api/v1/files/:id/relations",
"POST /api/v1/files/:id/relations/verdict",
"GET /api/v1/duplicates",
"POST /api/v1/export",
"POST /api/v1/files/:id/restore",
"POST /api/v1/files/:id/versions/:n/restore",
"GET /api/v1/trash",
"DELETE /api/v1/files/:id", "DELETE /api/v1/files/:id",
"POST /api/v1/files/upload", "POST /api/v1/files/upload",
"GET /api/v1/users/resolve", "GET /api/v1/users/resolve",
"PATCH /api/v1/users/me/password", "PATCH /api/v1/users/me/password",
"GET /api/v1/users/me/usage",
"GET /api/v1/devices",
"DELETE /api/v1/devices/:id",
"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", "POST /api/v1/ocr/jobs",
"GET /api/v1/ocr/jobs/:id", "GET /api/v1/ocr/jobs/:id",
@@ -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;
@@ -0,0 +1 @@
DROP INDEX IF EXISTS idx_resources_trashed_active;
@@ -0,0 +1,7 @@
-- V3 corbeille : `deleted_at` est le timestamp de trash (restauration =
-- `deleted_at = NULL`, purge = hard delete après 30j via PurgeExpired).
-- Toutes les lectures filtrent déjà `deleted_at IS NULL` : les trashés sont
-- invisibles partout sauf via les requêtes dédiées (ListTrashed). Cet index
-- partiel accélère la corbeille (`GET /trash`) et la passe de purge.
CREATE INDEX IF NOT EXISTS idx_resources_trashed_active
ON resources(user_id, deleted_at) WHERE deleted_at IS NOT NULL;
@@ -0,0 +1 @@
DROP TABLE IF EXISTS resource_versions;
@@ -0,0 +1,19 @@
-- V3 versions : historique léger des octets écrasés (N=3, cf. V3.md P1).
-- À chaque overwrite (upload ciblé), l'ancienne copie physique est déplacée
-- sous `stored_path` (relatif à UPLOAD_DIR) et sa métadonnée figée ici.
-- Restaurer = recopier vers l'emplacement live (l'actuel est à son tour
-- versionné). `ON DELETE CASCADE` : purger la ressource purge ses versions.
CREATE TABLE resource_versions (
id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'),
resource_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE,
version_no INT NOT NULL CHECK (version_no >= 1),
size_bytes BIGINT NOT NULL DEFAULT 0,
mime_type VARCHAR(255),
extension VARCHAR(64),
content_hash VARCHAR(128),
stored_path TEXT NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW(),
UNIQUE (resource_id, version_no)
);
CREATE INDEX idx_versions_resource ON resource_versions(resource_id);
@@ -0,0 +1 @@
DROP TABLE IF EXISTS resource_facts;
+23
View File
@@ -0,0 +1,23 @@
-- V3 extract générique (S2) : faits universels extraits du texte OCR
-- (dates, montants, émetteurs, références, type suggéré) — cf. V3.md §2.
-- `doc_type` n'est qu'un fait comme un autre (suggestion, jamais gate) ;
-- `origin` distingue l'auto (remplaçable à chaque passe) du `user` (S3,
-- correction en un tap — l'auto ne l'écrase jamais). Cascade : purger la
-- ressource purge ses faits.
CREATE TABLE resource_facts (
id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'),
resource_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE,
fact_type TEXT NOT NULL CHECK (fact_type IN (
'date', 'due_date', 'period', 'amount', 'issuer', 'reference', 'doc_type'
)),
value_text TEXT,
value_num NUMERIC,
value_date DATE,
confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
origin TEXT NOT NULL DEFAULT 'auto' CHECK (origin IN ('auto', 'user')),
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX idx_facts_resource ON resource_facts(resource_id);
CREATE INDEX idx_facts_type_value ON resource_facts(fact_type, value_text);
@@ -0,0 +1,2 @@
DROP INDEX IF EXISTS idx_resources_search_tsv;
ALTER TABLE resources DROP COLUMN IF EXISTS search_tsv;
@@ -0,0 +1,13 @@
-- V3 recherche (S4) : plein-texte français sur (nom + OCR).
-- Colonne générée stockée (`to_tsvector(regconfig, text)` est IMMUTABLE,
-- donc autorisée en GENERATED) : pas de trigger, backfill automatique des
-- lignes existantes. Index GIN. Les faits (`resource_facts`) sont joints à
-- la requête (jamais dupliqués) : ils pondèrent le rang sans jamais exclure
-- (humble par design — une confiance < 0.5 déclasse, cf. SearchDocuments).
ALTER TABLE resources
ADD COLUMN search_tsv TSVECTOR
GENERATED ALWAYS AS (
to_tsvector('french', COALESCE(name, '') || ' ' || COALESCE(ocr_text, ''))
) STORED;
CREATE INDEX IF NOT EXISTS idx_resources_search_tsv ON resources USING GIN (search_tsv);
@@ -0,0 +1,2 @@
ALTER TABLE resources DROP COLUMN IF EXISTS scan_session_id;
DROP TABLE IF EXISTS resource_links;
+32
View File
@@ -0,0 +1,32 @@
-- V3 relations documentaires (S5) : graphe auto + verdicts utilisateur.
-- `resource_links` : arêtes orientées (from_id → to_id) typées, avec
-- confiance et origine. `duplicate_of` (même content_hash), `same_scan`
-- (même session de scan, déterministe), `same_issuer` / `same_reference`
-- (faits normalisés égaux). `version_of` non matérialisé : les versions
-- vivent DANS la ressource (resource_versions, 000018), pas entre ressources.
-- `created_by` : 'auto' (dérivé serveur, écrasable) vs 'user' (verdict
-- explicite — la réconciliation ne touche jamais aux verdicts). Les
-- invalidations (confidence 0) sont conservées (pas de re-création auto).
-- `resources.scan_session_id` : session de scan opaque fournie par le client
-- dans le payload `create_resource` (zéro nouvelle op) — le serveur en
-- déduit les arêtes `same_scan`.
CREATE TABLE resource_links (
id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'),
from_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE,
to_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE,
link_type TEXT NOT NULL CHECK (link_type IN (
'same_scan', 'duplicate_of', 'same_issuer', 'same_reference'
)),
confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
created_by TEXT NOT NULL DEFAULT 'auto' CHECK (created_by IN ('auto', 'user')),
created_at TIMESTAMPTZ DEFAULT NOW(),
CHECK (from_id != to_id),
UNIQUE (from_id, to_id, link_type)
);
CREATE INDEX idx_links_from ON resource_links(from_id);
CREATE INDEX idx_links_to ON resource_links(to_id);
ALTER TABLE resources ADD COLUMN scan_session_id TEXT;
CREATE INDEX IF NOT EXISTS idx_resources_scan_session ON resources(user_id, scan_session_id)
WHERE scan_session_id IS NOT NULL;
@@ -0,0 +1 @@
ALTER TABLE users DROP COLUMN IF EXISTS token_version;
@@ -0,0 +1,6 @@
-- V3 S6 : révocation des tokens au changement de mot de passe.
-- `token_version` est bumpé par PATCH /users/me/password ; le middleware
-- rejette les tokens dont le claim `tv` diffère (401). Défaut 0 : les tokens
-- pré-V3 (sans claim `tv`, lus comme 0) restent valides jusqu'au premier
-- changement de mot de passe — montée en version sans coupure.
ALTER TABLE users ADD COLUMN token_version INT NOT NULL DEFAULT 0;
@@ -0,0 +1,2 @@
-- No-op : la colonne prédate cette migration (000001), on ne la supprime pas.
SELECT 1;
@@ -0,0 +1,6 @@
-- V3 S6 (A2) : quota de stockage par compte (10 Go par défaut, V2.md §3.1).
-- Garde-fou à l'upload (413 QUOTA_EXCEEDED) + affichage `GET /users/me/usage`.
-- L'usage est calculé (somme `size_bytes` des fichiers vifs), jamais stocké.
-- Note : la colonne existe depuis 000001 (modèle V2) — IF NOT EXISTS pour
-- les bases créées avant/après, sans double ajout.
ALTER TABLE users ADD COLUMN IF NOT EXISTS storage_quota_bytes BIGINT NOT NULL DEFAULT 10737418240;
@@ -0,0 +1 @@
DROP TABLE IF EXISTS resource_previews;
@@ -0,0 +1,13 @@
-- V3 S7 : vignettes serveur pour les fichiers cloud-only (la galerie reste
-- < 1 s sans rapatrier les octets). `resource_previews` mémorise la
-- génération servie (taille + updated_at sources) pour ne régénérer que sur
-- changement ; le fichier vit sous UPLOAD_DIR/.previews/<resource_id>.jpg
-- (jamais versionné, reconstruit à la demande). Images : pur Go (stdlib +
-- x/image). PDF : `pdftoppm` (poppler, cf. Dockerfile) page 1 ; sans l'outil
-- ou autre type → pas de preview (404 NO_PREVIEW, l'UI montre l'icône).
CREATE TABLE resource_previews (
resource_id TEXT PRIMARY KEY REFERENCES resources(resource_id) ON DELETE CASCADE,
src_size_bytes BIGINT NOT NULL,
src_updated_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
+185
View File
@@ -333,6 +333,191 @@ func TestMigrationsUpDown(t *testing.T) {
t.Error("index unique partiel (id) WHERE revoked_at IS NULL manquant sur share_links") 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")
// --- 000017 : corbeille (index partiel deleted_at) ----------------------
var trashedIdx 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_trashed_active%'`).Scan(&trashedIdx)
if err != nil {
t.Fatalf("000017 index: %v", err)
}
if trashedIdx == 0 {
t.Error("index idx_resources_trashed_active manquant après 000017")
}
// --- 000018 : versions --------------------------------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "schema_migrations")
assertHexCheck(t, conn, "resource_versions", "id")
var versionUniq int
err = conn.QueryRow(`
SELECT COUNT(*) FROM pg_index i
JOIN pg_class t ON t.oid = i.indrelid
WHERE t.relname = 'resource_versions' AND i.indisunique
AND ARRAY(SELECT a.attname FROM unnest(i.indkey) WITH ORDINALITY k(attnum, ord)
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
ORDER BY k.ord)::text[] = ARRAY['resource_id','version_no']`).Scan(&versionUniq)
if err != nil {
t.Fatalf("versions unique: %v", err)
}
if versionUniq == 0 {
t.Error("contrainte UNIQUE(resource_id, version_no) manquante sur resource_versions après 000018")
}
// --- 000019 : faits génériques -----------------------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "resource_facts", "schema_migrations")
assertHexCheck(t, conn, "resource_facts", "id")
var factTypeCheck int
err = conn.QueryRow(`
SELECT COUNT(*) FROM pg_constraint c
JOIN pg_class t ON t.oid = c.conrelid
WHERE t.relname = 'resource_facts'
AND pg_get_constraintdef(c.oid) LIKE '%doc_type%'
AND pg_get_constraintdef(c.oid) LIKE '%due_date%'`).Scan(&factTypeCheck)
if err != nil {
t.Fatalf("check resource_facts.fact_type: %v", err)
}
if factTypeCheck == 0 {
t.Error("CHECK fact_type manquant sur resource_facts après 000019")
}
// --- 000020 : plein-texte ----------------------------------------------
var tsvCol int
err = conn.QueryRow(`
SELECT COUNT(*) FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'resources' AND column_name = 'search_tsv'`).Scan(&tsvCol)
if err != nil {
t.Fatalf("search_tsv column: %v", err)
}
if tsvCol == 0 {
t.Error("colonne resources.search_tsv manquante après 000020")
}
var tsvIdx 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_search_tsv%'`).Scan(&tsvIdx)
if err != nil {
t.Fatalf("000020 index: %v", err)
}
if tsvIdx == 0 {
t.Error("index idx_resources_search_tsv manquant après 000020")
}
// --- 000021 : graphe documentaire ----------------------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "resource_facts", "resource_links", "schema_migrations")
// resource_links.id : CHECK 32-hex (requête ciblée — le helper
// générique matcherait `from_id <> to_id` qui contient aussi "id").
var linksIDCheck string
err = conn.QueryRow(`
SELECT pg_get_constraintdef(c.oid)
FROM pg_constraint c
JOIN pg_class t ON t.oid = c.conrelid
WHERE t.relname = 'resource_links' AND c.conname = 'resource_links_id_check'`).Scan(&linksIDCheck)
if err != nil {
t.Fatalf("contrainte CHECK(resource_links.id) manquante: %v", err)
}
if !strings.Contains(linksIDCheck, "^[0-9a-f]{32}$") {
t.Errorf("CHECK resource_links.id attendu 32-hex, obtenu : %s", linksIDCheck)
}
var linksUniq int
err = conn.QueryRow(`
SELECT COUNT(*) FROM pg_index i
JOIN pg_class t ON t.oid = i.indrelid
WHERE t.relname = 'resource_links' AND i.indisunique
AND ARRAY(SELECT a.attname FROM unnest(i.indkey) WITH ORDINALITY k(attnum, ord)
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
ORDER BY k.ord)::text[] = ARRAY['from_id','to_id','link_type']`).Scan(&linksUniq)
if err != nil {
t.Fatalf("links unique: %v", err)
}
if linksUniq == 0 {
t.Error("contrainte UNIQUE(from_id, to_id, link_type) manquante sur resource_links après 000021")
}
var scanSessionCol int
err = conn.QueryRow(`
SELECT COUNT(*) FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'resources' AND column_name = 'scan_session_id'`).Scan(&scanSessionCol)
if err != nil {
t.Fatalf("scan_session_id column: %v", err)
}
if scanSessionCol == 0 {
t.Error("colonne resources.scan_session_id manquante après 000021")
}
// --- 000022 : révocation tokens ------------------------------------------
var tvCol int
err = conn.QueryRow(`
SELECT COUNT(*) FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'users' AND column_name = 'token_version'`).Scan(&tvCol)
if err != nil {
t.Fatalf("token_version column: %v", err)
}
if tvCol == 0 {
t.Error("colonne users.token_version manquante après 000022")
}
// --- 000023 : quota (colonne héritée de 000001, IF NOT EXISTS) ------------
var quotaCol int
err = conn.QueryRow(`
SELECT COUNT(*) FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'users' AND column_name = 'storage_quota_bytes'`).Scan(&quotaCol)
if err != nil {
t.Fatalf("storage_quota_bytes column: %v", err)
}
if quotaCol == 0 {
t.Error("colonne users.storage_quota_bytes manquante après 000023")
}
// --- 000024 : vignettes serveur ------------------------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "resource_facts", "resource_links", "resource_previews", "schema_migrations")
if err := MigrateDownDatabase(url); err != nil { if err := MigrateDownDatabase(url); err != nil {
t.Fatalf("migrate down: %v", err) t.Fatalf("migrate down: %v", err)
} }
+408
View File
@@ -0,0 +1,408 @@
// Package extract derives generic, verifiable facts from OCR text (V3 S2).
//
// Rules-based French heuristics, zero ML : every fact carries a confidence,
// low-confidence facts are suggested (greyed in UI) and user-correctable (S3),
// and search demotes but never excludes on them. No LLM, no network, pure
// stdlib — it runs inside the OCR worker right after Tesseract.
package extract
import (
"fmt"
"regexp"
"strconv"
"strings"
"unicode"
)
// Fact types — mirror of the resource_facts CHECK (migration 000019).
type FactType string
const (
FactDate FactType = "date"
FactDueDate FactType = "due_date"
FactPeriod FactType = "period"
FactAmount FactType = "amount"
FactIssuer FactType = "issuer"
FactReference FactType = "reference"
FactDocType FactType = "doc_type"
)
// Fact is one extracted statement. ValueText holds issuer names, reference
// codes ("facture:FA-2026-0031"), doc types and periods ("2026-03") ;
// ValueNum holds amounts (HasNum) ; ValueDate holds ISO dates ("2026-03-12").
type Fact struct {
Type FactType
ValueText string
ValueNum float64
HasNum bool
ValueDate string
Confidence float64
}
// MaxFacts caps the output per resource (OCR garbage must stay bounded).
const MaxFacts = 50
// FromText extracts generic facts from raw OCR text. Deterministic output
// order (document order within each type, types in fixed order), duplicates
// removed.
func FromText(text string) []Fact {
e := &extractor{seen: map[string]bool{}}
e.extract(collectLines(text))
out := e.facts
if len(out) > MaxFacts {
out = out[:MaxFacts]
}
return out
}
type extractor struct {
facts []Fact
seen map[string]bool
}
func (e *extractor) add(f Fact) {
if f.Confidence < 0 {
f.Confidence = 0
}
if f.Confidence > 1 {
f.Confidence = 1
}
key := string(f.Type) + "\x00" + f.ValueText + "\x00" + f.ValueDate + "\x00" + fmt.Sprintf("%.2f", f.ValueNum)
if e.seen[key] {
return
}
e.seen[key] = true
e.facts = append(e.facts, f)
}
type line struct {
raw string
folded string
}
func collectLines(text string) []line {
raw := strings.Split(text, "\n")
out := make([]line, 0, len(raw))
for _, r := range raw {
r = strings.TrimSpace(strings.ReplaceAll(r, "\t", " "))
if r == "" {
continue
}
out = append(out, line{raw: r, folded: fold(r)})
}
return out
}
func (e *extractor) extract(lines []line) {
for _, l := range lines {
e.extractAmounts(l)
e.extractDates(l)
e.extractReferences(l)
}
e.extractIssuers(lines)
e.extractDocType(lines)
}
// --- amounts ---------------------------------------------------------------
// Note : pas de `\b` après `€` — c'est un symbole (non-mot), donc il n'y a
// jamais de frontière avec un espace ou une fin de ligne. `eur` garde son
// `\b` (évite "europe"), `euros?` n'en a pas besoin.
var amountPattern = regexp.MustCompile(`(\d[\d\s\x{a0}\x{202f}]*[,\.]\d{2}|\d[\d\s\x{a0}\x{202f}]*)\s*(€|euros?|eur\b)`)
func (e *extractor) extractAmounts(l line) {
// Percentages are not amounts.
if strings.Contains(l.raw, "%") && !strings.ContainsAny(l.raw, "€") {
return
}
for _, m := range amountPattern.FindAllStringSubmatch(l.raw, -1) {
num, ok := parseFrenchNumber(m[1])
if !ok || num <= 0 || num >= 1e13 {
continue
}
conf := 0.7
if amountKeywordPattern.MatchString(l.folded) {
conf = 0.9
}
e.add(Fact{Type: FactAmount, ValueNum: num, HasNum: true, ValueText: formatAmount(num), Confidence: conf})
}
}
var amountKeywordPattern = regexp.MustCompile(`\b(total|montant|a payer|net|ttc|solde|du)\b`)
func formatAmount(num float64) string {
return strconv.FormatFloat(num, 'f', 2, 64) + " €"
}
// parseFrenchNumber reads "1 234,56" / "1234.56" / "84 €"-style magnitudes.
// Comma = decimal separator (French), dots/spaces (incl. NBSP U+00A0 and
// narrow NBSP U+202F, common in "1 234 €") = thousands.
func parseFrenchNumber(s string) (float64, bool) {
s = strings.ReplaceAll(s, "\u00a0", "")
s = strings.ReplaceAll(s, "\u202f", "")
s = strings.ReplaceAll(s, " ", "")
if strings.Contains(s, ",") {
s = strings.ReplaceAll(s, ".", "")
s = strings.ReplaceAll(s, ",", ".")
}
num, err := strconv.ParseFloat(s, 64)
return num, err == nil
}
// --- dates -----------------------------------------------------------------
var numericDatePattern = regexp.MustCompile(`\b(\d{1,2})\s*[/\-.]\s*(\d{1,2})\s*[/\-.]\s*(\d{2}|\d{4})\b`)
var writtenDatePattern = regexp.MustCompile(`\b(\d{1,2})\s+(janv(?:ier)?|fev(?:rier)?|mars|avr(?:il)?|mai|juin|juil(?:let)?|aout|sept?(?:embre)?|oct(?:obre)?|nov(?:embre)?|dec(?:embre)?)\s+(\d{4})\b`)
var periodPattern = regexp.MustCompile(`\b(janv(?:ier)?|fev(?:rier)?|mars|avr(?:il)?|mai|juin|juil(?:let)?|aout|sept?(?:embre)?|oct(?:obre)?|nov(?:embre)?|dec(?:embre)?)\s+(\d{4})\b`)
var monthNumbers = map[string]int{
"janv": 1, "janvier": 1, "fev": 2, "fevrier": 2, "mars": 3,
"avr": 4, "avril": 4, "mai": 5, "juin": 6, "juil": 7,
"juillet": 7, "aout": 8, "sept": 9, "septembre": 9, "oct": 10,
"octobre": 10, "nov": 11, "novembre": 11, "dec": 12, "decembre": 12,
}
var dueKeywordPattern = regexp.MustCompile(`\b(echeance|a payer avant|date limite|avant le|regler avant|paiement avant)\b`)
func fullYear(yy int) int {
if yy < 100 {
if yy >= 70 {
return 1900 + yy
}
return 2000 + yy
}
return yy
}
func isoDate(y, m, d int) (string, bool) {
if m < 1 || m > 12 || d < 1 || d > 31 || y < 1900 || y > 2100 {
return "", false
}
return fmt.Sprintf("%04d-%02d-%02d", y, m, d), true
}
func (e *extractor) extractDates(l line) {
isDue := dueKeywordPattern.MatchString(l.folded)
for _, m := range numericDatePattern.FindAllStringSubmatch(l.raw, -1) {
d, _ := strconv.Atoi(m[1])
mo, _ := strconv.Atoi(m[2])
y, _ := strconv.Atoi(m[3])
iso, ok := isoDate(fullYear(y), mo, d)
if !ok {
continue
}
typ := FactDate
conf := 0.6
if isDue {
typ, conf = FactDueDate, 0.8
}
e.add(Fact{Type: typ, ValueDate: iso, ValueText: iso, Confidence: conf})
}
for _, m := range writtenDatePattern.FindAllStringSubmatch(l.folded, -1) {
d, _ := strconv.Atoi(m[1])
mo := monthNumbers[m[2]]
y, _ := strconv.Atoi(m[3])
iso, ok := isoDate(y, mo, d)
if !ok {
continue
}
typ := FactDate
conf := 0.7
if isDue {
typ, conf = FactDueDate, 0.85
}
e.add(Fact{Type: typ, ValueDate: iso, ValueText: iso, Confidence: conf})
}
for _, m := range periodPattern.FindAllStringSubmatch(l.folded, -1) {
mo := monthNumbers[m[1]]
y, _ := strconv.Atoi(m[2])
if mo == 0 || y < 1900 || y > 2100 {
continue
}
e.add(Fact{Type: FactPeriod, ValueText: fmt.Sprintf("%04d-%02d", y, mo), Confidence: 0.7})
}
}
// --- references ------------------------------------------------------------
// referencePattern catches "facture n° FA-2026-0031", "contrat : ABC123",
// "client 42" — the code must contain a digit (avoids "FACTURE DU MOIS").
var referencePattern = regexp.MustCompile(`(?i)\b(facture|contrat|client|compte|dossier|bulletin|commande|devis|attestation|police)\s*(n°|no|num(?:ero)?|number|ref(?:erence)?)?\s*[:\-#]?\s*([A-Z0-9][A-Z0-9\-/\.]{1,29})`)
var bareRefPattern = regexp.MustCompile(`\bn°\s*([A-Z0-9][A-Z0-9\-/]{2,20})`)
var siretPattern = regexp.MustCompile(`(?i)\b(siret|siren|rcs)\b[^\d]{0,10}(\d{3}\s?\d{3}\s?\d{3}(?:\s?\d{5})?)`)
var ibanPattern = regexp.MustCompile(`\bFR\s?\d{2}(?:\s?[0-9A-Z]{4}){5}\s?[0-9A-Z]{0,3}\b`)
func hasDigit(s string) bool {
for _, r := range s {
if r >= '0' && r <= '9' {
return true
}
}
return false
}
func (e *extractor) extractReferences(l line) {
for _, m := range referencePattern.FindAllStringSubmatch(l.raw, -1) {
code := strings.Trim(m[3], "-/.")
if !hasDigit(code) || len(code) < 3 {
continue
}
kind := strings.ToLower(m[1])
e.add(Fact{Type: FactReference, ValueText: kind + ":" + code, Confidence: 0.75})
}
for _, m := range bareRefPattern.FindAllStringSubmatch(l.raw, -1) {
code := m[1]
if !hasDigit(code) {
continue
}
e.add(Fact{Type: FactReference, ValueText: "ref:" + code, Confidence: 0.6})
}
if m := siretPattern.FindStringSubmatch(l.raw); m != nil {
digits := strings.Join(strings.Fields(m[2]), " ")
e.add(Fact{Type: FactReference, ValueText: strings.ToLower(m[1]) + ":" + digits, Confidence: 0.9})
}
if m := ibanPattern.FindString(l.raw); m != "" {
compact := strings.ReplaceAll(m, " ", "")
if len(compact) == 27 {
// Store masked (privacy) : only the last 4 chars.
e.add(Fact{Type: FactReference, ValueText: "rib:••••" + compact[len(compact)-4:], Confidence: 0.9})
}
}
}
// --- issuers ---------------------------------------------------------------
var companySuffixPattern = regexp.MustCompile(`(?i)\b(sarl|sas|sa|eurl|sasu|sci|eirl|snc|sasau)\b`)
func isCapsLine(s string) bool {
letters := 0
for _, r := range s {
if unicode.IsLetter(r) {
letters++
if unicode.IsLower(r) {
return false
}
}
}
return letters >= 3
}
func (e *extractor) extractIssuers(lines []line) {
found := 0
checked := 0
for _, l := range lines {
if checked >= 8 || found >= 2 {
break
}
raw := strings.TrimSpace(l.raw)
if len([]rune(raw)) < 3 || len([]rune(raw)) > 60 {
continue
}
if strings.Contains(raw, "@") || strings.HasPrefix(strings.ToLower(raw), "http") {
continue
}
checked++
if !isCapsLine(raw) {
continue
}
// Skip lines that are really dates/amounts/references in disguise.
if numericDatePattern.MatchString(raw) || amountPattern.MatchString(raw) || bareRefPattern.MatchString(raw) {
continue
}
conf := 0.45
if found == 0 {
conf = 0.55
}
if companySuffixPattern.MatchString(raw) {
conf = 0.75
}
e.add(Fact{Type: FactIssuer, ValueText: raw, Confidence: conf})
found++
}
}
// --- doc_type suggestion ---------------------------------------------------
// docTypeKeywords maps a suggested type to weighted French keywords (folded).
// A type is emitted when its score reaches docTypeThreshold — the type is a
// humble suggestion (S3-correctable), never a gate.
var docTypeKeywords = []struct {
typ string
keywords map[string]int
}{
{"facture", map[string]int{"facture": 2, "tva": 1, "montant ttc": 2, "total ttc": 2, "a payer": 1, "devis": 1}},
{"bulletin", map[string]int{"bulletin": 2, "salaire": 2, "paie": 1, "net social": 2, "brut": 1}},
{"impot", map[string]int{"impot": 2, "revenu fiscal": 2, "taxe fonciere": 2, "taxe d habitation": 1, "avis d impot": 2}},
{"contrat", map[string]int{"contrat": 2, "bail": 2, "convention": 1, "article ": 1, "assurance": 1}},
{"ordonnance", map[string]int{"ordonnance": 2, "posologie": 2, "docteur": 1, "traitement": 1}},
{"attestation", map[string]int{"attestation": 2, "certifie": 1, "certificat": 1, "atteste": 1}},
{"rib", map[string]int{"rib": 2, "iban": 2, "bic": 1}},
{"identite", map[string]int{"carte d identite": 2, "passeport": 2, "permis de conduire": 2, "nationalite": 1}},
}
const docTypeThreshold = 2
func (e *extractor) extractDocType(lines []line) {
joined := "\n"
for _, l := range lines {
joined += l.folded + "\n"
}
best, bestScore := "", 0
for _, dt := range docTypeKeywords {
score := 0
for kw, w := range dt.keywords {
if strings.Contains(joined, kw) {
score += w
}
}
if score > bestScore {
best, bestScore = dt.typ, score
}
}
if bestScore >= docTypeThreshold {
conf := 0.5 + 0.1*float64(bestScore)
if conf > 0.85 {
conf = 0.85
}
e.add(Fact{Type: FactDocType, ValueText: best, Confidence: conf})
}
}
// --- folding ---------------------------------------------------------------
// fold lowercases French text and strips accents (œ→oe, æ→ae, ç→c) for
// keyword matching. stdlib-only (no x/text dependency churn).
func fold(s string) string {
var b strings.Builder
b.Grow(len(s))
for _, r := range strings.ToLower(s) {
switch r {
case 'à', 'â', 'ä':
b.WriteRune('a')
case 'é', 'è', 'ê', 'ë':
b.WriteRune('e')
case 'î', 'ï':
b.WriteRune('i')
case 'ô', 'ö':
b.WriteRune('o')
case 'ù', 'û', 'ü':
b.WriteRune('u')
case 'ÿ':
b.WriteRune('y')
case 'ç':
b.WriteRune('c')
case 'œ':
b.WriteString("oe")
case 'æ':
b.WriteString("ae")
default:
b.WriteRune(r)
}
}
return b.String()
}
+183
View File
@@ -0,0 +1,183 @@
package extract
import (
"testing"
)
func factsByType(facts []Fact) map[FactType][]Fact {
out := map[FactType][]Fact{}
for _, f := range facts {
out[f.Type] = append(out[f.Type], f)
}
return out
}
func hasText(facts []Fact, want string) bool {
for _, f := range facts {
if f.ValueText == want {
return true
}
}
return false
}
const edfBill = `EDF - SERVICE CLIENTS
TSA 12345
Facture n° FA-2026-0031 du 12/03/2026
Période : mars 2026
Montant total TTC : 1 234,56 €
À payer avant le 12/04/2026
Référence client : 123456789
`
func TestFactureEDF(t *testing.T) {
by := factsByType(FromText(edfBill))
if !hasText(by[FactReference], "facture:FA-2026-0031") {
t.Errorf("référence facture manquante: %+v", by[FactReference])
}
if !hasText(by[FactDate], "2026-03-12") {
t.Errorf("date émission manquante: %+v", by[FactDate])
}
if !hasText(by[FactDueDate], "2026-04-12") {
t.Errorf("échéance manquante: %+v", by[FactDueDate])
}
if !hasText(by[FactPeriod], "2026-03") {
t.Errorf("période manquante: %+v", by[FactPeriod])
}
found := false
for _, f := range by[FactAmount] {
if f.HasNum && f.ValueNum == 1234.56 && f.Confidence >= 0.9 {
found = true
}
}
if !found {
t.Errorf("montant 1234.56 (conf 0.9) manquant: %+v", by[FactAmount])
}
if !hasText(by[FactIssuer], "EDF - SERVICE CLIENTS") {
t.Errorf("émetteur manquant: %+v", by[FactIssuer])
}
if !hasText(by[FactDocType], "facture") {
t.Errorf("doc_type facture manquant: %+v", by[FactDocType])
}
}
const bulletin = `BULLETIN DE SALAIRE
DUPONT Jean
Période : janvier 2026
Salaire brut : 2 845,00 €
Net social : 2 210,35 €
SIRET 123 456 789 00012
`
func TestBulletinSalaire(t *testing.T) {
by := factsByType(FromText(bulletin))
if !hasText(by[FactDocType], "bulletin") {
t.Errorf("doc_type bulletin manquant: %+v", by[FactDocType])
}
if !hasText(by[FactPeriod], "2026-01") {
t.Errorf("période manquante: %+v", by[FactPeriod])
}
if !hasText(by[FactReference], "siret:123 456 789 00012") {
t.Errorf("siret manquant: %+v", by[FactReference])
}
amounts := map[float64]bool{}
for _, f := range by[FactAmount] {
if f.HasNum {
amounts[f.ValueNum] = true
}
}
if !amounts[2845.00] || !amounts[2210.35] {
t.Errorf("montants bulletin manquants: %+v", by[FactAmount])
}
}
const ordonnance = `Dr MARTIN Sophie
Ordonnance du 3 mars 2026
Doliprane 1000mg — 1 matin et soir pendant 7 jours
`
func TestOrdonnance(t *testing.T) {
by := factsByType(FromText(ordonnance))
if !hasText(by[FactDocType], "ordonnance") {
t.Errorf("doc_type ordonnance manquant: %+v", by[FactDocType])
}
if !hasText(by[FactDate], "2026-03-03") {
t.Errorf("date manquante: %+v", by[FactDate])
}
if len(by[FactAmount]) != 0 {
t.Errorf("1000mg ne doit pas être un montant: %+v", by[FactAmount])
}
}
const rib = `RELEVÉ D'IDENTITÉ BANCAIRE
Titulaire : DUPONT Jean
IBAN : FR76 1234 5678 9012 3456 7890 123
BIC : AGRIFRPP
`
func TestRIBMasque(t *testing.T) {
by := factsByType(FromText(rib))
if !hasText(by[FactDocType], "rib") {
t.Errorf("doc_type rib manquant: %+v", by[FactDocType])
}
if !hasText(by[FactReference], "rib:••••0123") {
t.Errorf("IBAN masqué manquant: %+v", by[FactReference])
}
// L'IBAN complet ne doit jamais fuiter dans les faits.
for _, f := range by[FactReference] {
if len(f.ValueText) > 20 {
t.Errorf("fuite IBAN en clair: %q", f.ValueText)
}
}
}
func TestTexteVideEtBruit(t *testing.T) {
if got := FromText(""); len(got) != 0 {
t.Errorf("vide → %d faits, attendu 0", len(got))
}
// Bruit OCR sans structure : pas de doc_type, pas de montant.
by := factsByType(FromText("lorem ipsum\nbla bla 99\n///"))
if len(by[FactDocType]) != 0 {
t.Errorf("doc_type sur bruit: %+v", by[FactDocType])
}
if len(by[FactAmount]) != 0 {
t.Errorf("montant sur bruit: %+v", by[FactAmount])
}
}
func TestCourrierSimpleSansType(t *testing.T) {
// Tous les documents comptent : un courrier sans mots-clés métier donne
// des faits (date) mais aucun doc_type — jamais pénalisé.
by := factsByType(FromText("Bonjour,\nmerci de me recontacter.\nCordialement.\nParis, le 05/06/2026\n"))
if !hasText(by[FactDate], "2026-06-05") {
t.Errorf("date courrier manquante: %+v", by[FactDate])
}
if len(by[FactDocType]) != 0 {
t.Errorf("pas de doc_type attendu: %+v", by[FactDocType])
}
}
func TestAnneesCourtesEtFormats(t *testing.T) {
by := factsByType(FromText("Fait le 01.02.99\nÉchéance 15-08-26\n"))
if !hasText(by[FactDate], "1999-02-01") {
t.Errorf("année courte 99 → 1999: %+v", by[FactDate])
}
if !hasText(by[FactDueDate], "2026-08-15") {
t.Errorf("année courte 26 → 2026: %+v", by[FactDueDate])
}
}
func TestBornes(t *testing.T) {
// Dates invalides ignorées, pas de crash.
by := factsByType(FromText("le 45/13/2026 et le 00/00/0000"))
if len(by[FactDate])+len(by[FactDueDate]) != 0 {
t.Errorf("dates invalides extraites: %+v", by)
}
// Confiances toujours dans [0,1].
for _, f := range FromText(edfBill + bulletin + ordonnance + rib) {
if f.Confidence < 0 || f.Confidence > 1 {
t.Errorf("confiance hors bornes: %+v", f)
}
}
}
+6 -4
View File
@@ -7,11 +7,15 @@ require (
github.com/gin-gonic/gin v1.12.0 github.com/gin-gonic/gin v1.12.0
github.com/golang-migrate/migrate/v4 v4.19.1 github.com/golang-migrate/migrate/v4 v4.19.1
github.com/joho/godotenv v1.5.1 github.com/joho/godotenv v1.5.1
github.com/ledongthuc/pdf v0.0.0-20260907135840-6c8c28e0e8a0
github.com/lib/pq v1.12.3 github.com/lib/pq v1.12.3
golang.org/x/crypto v0.52.0
golang.org/x/image v0.46.0
) )
require ( require (
aidanwoods.dev/go-result v0.3.1 // indirect aidanwoods.dev/go-result v0.3.1 // indirect
github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0 // indirect
github.com/bytedance/gopkg v0.1.3 // indirect github.com/bytedance/gopkg v0.1.3 // indirect
github.com/bytedance/sonic v1.15.0 // indirect github.com/bytedance/sonic v1.15.0 // indirect
github.com/bytedance/sonic/loader v0.5.0 // indirect github.com/bytedance/sonic/loader v0.5.0 // indirect
@@ -25,7 +29,6 @@ require (
github.com/goccy/go-yaml v1.19.2 // indirect github.com/goccy/go-yaml v1.19.2 // indirect
github.com/json-iterator/go v1.1.12 // indirect github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/ledongthuc/pdf v0.0.0-20260907135840-6c8c28e0e8a0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
@@ -37,9 +40,8 @@ require (
github.com/ugorji/go/codec v1.3.1 // indirect github.com/ugorji/go/codec v1.3.1 // indirect
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
golang.org/x/arch v0.22.0 // indirect golang.org/x/arch v0.22.0 // indirect
golang.org/x/crypto v0.52.0 // indirect
golang.org/x/net v0.54.0 // indirect golang.org/x/net v0.54.0 // indirect
golang.org/x/sys v0.45.0 // indirect golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.37.0 // indirect golang.org/x/text v0.42.0 // indirect
google.golang.org/protobuf v1.36.10 // indirect google.golang.org/protobuf v1.36.10 // indirect
) )
+8 -4
View File
@@ -6,6 +6,8 @@ github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0 h1:BVts5dexXf4i+JX8tXlKT0aKoi38JwTXSe+3WUneX0k=
github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0/go.mod h1:FDIQmoMNJJl5/k7upZEnGvgWVZfFeE6qHeN7iCMbCsA=
github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M= github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM= github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE= github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
@@ -136,13 +138,15 @@ golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI=
golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988= golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988=
golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=
golang.org/x/image v0.46.0 h1:b1+oYj0Jbp6K5MDT4i4/eZpYlk3V8SJhhDKh6LBHAyQ=
golang.org/x/image v0.46.0/go.mod h1:3B3W05VGVQyuXucLINLjXKrqISASfi4Xj+iCVkLMwew=
golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w= golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ= golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+10 -3
View File
@@ -2,6 +2,7 @@ package handlers
import ( import (
"errors" "errors"
"log"
"net/http" "net/http"
"strings" "strings"
"sync" "sync"
@@ -156,7 +157,7 @@ func AuthLogin(c *gin.Context) {
return return
} }
token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID) token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID, user.TokenVersion)
if err != nil { if err != nil {
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token") api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token")
return return
@@ -179,8 +180,9 @@ type changePasswordRequest struct {
} }
// ChangePassword met à jour le hash du compte connecté. Le mot de passe // ChangePassword met à jour le hash du compte connecté. Le mot de passe
// courant est requis. Limite connue V1 : les tokens déjà émis restent valides // courant est requis. V3 S6 : le changement bumpe `token_version` — tous les
// jusqu'à expiration (7 j, pas de révocation) — cf. docs/api-v1.md §7. // autres tokens (autres devices, sessions volées) sont révoqués aussitôt
// (le token courant aussi : le client doit se reconnecter).
func ChangePassword(c *gin.Context) { func ChangePassword(c *gin.Context) {
if Store == nil || Store.Repository == nil { if Store == nil || Store.Repository == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -217,6 +219,11 @@ func ChangePassword(c *gin.Context) {
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update password") api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update password")
return return
} }
// Révocation (V3 S6) : bump best-effort — un échec ici ne doit pas faire
// croire que le password n'a pas changé (il l'est, ligne ci-dessus).
if err := Store.Repository.Users.BumpTokenVersion(userID); err != nil {
log.Printf("auth: bump token_version(%s): %v", userID, err)
}
api.OK(c, gin.H{"id": userID}) api.OK(c, gin.H{"id": userID})
} }
+48
View File
@@ -105,3 +105,51 @@ func DevicesRegister(c *gin.Context) {
api.OK(c, gin.H{"deviceId": req.DeviceID}) api.OK(c, gin.H{"deviceId": req.DeviceID})
} }
// DeviceDTO expose un device du compte (A1 — voir / révoquer).
type DeviceDTO struct {
DeviceID string `json:"deviceId"`
LastSeenAt *int64 `json:"lastSeenAt"`
}
// DevicesList renvoie les devices du compte connecté (`GET /devices`,
// dernier login = ce compte, les plus récemment vus d'abord).
func DevicesList(c *gin.Context) {
if Store == nil || Store.Repository == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
rows, err := Store.Repository.Devices.ListByUser(userID)
if err != nil {
writeError(c, err)
return
}
out := make([]DeviceDTO, 0, len(rows))
for _, row := range rows {
out = append(out, DeviceDTO{DeviceID: row.DeviceID, LastSeenAt: row.LastSeenAt})
}
api.OK(c, out)
}
// DeviceRevoke révoque un device du compte (`DELETE /devices/:id`, A1 —
// téléphone perdu). Avec EnforceDeviceExists, ses tokens deviennent 401 et
// son login est refusé (ré-enregistrement explicite requis). Ligne absente
// ou d'un autre compte → 404 (pas d'énumération).
func DeviceRevoke(c *gin.Context) {
if Store == nil || Store.Repository == 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", "device not found")
return
}
if err := Store.Repository.Devices.Revoke(userID, id); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": id})
}
+46
View File
@@ -0,0 +1,46 @@
package handlers
import (
"fmt"
"net/http"
"time"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
)
type exportRequest struct {
Password string `json:"password"`
}
// ExportFull streame un zip AES-256 du compte (V3 S7 C3) :
// `POST /export { password }` (mot de passe en corps JSON, jamais en query
// — pas de fuite dans les logs). Chaque entrée (fichiers + manifest.json)
// est chiffrée. Scope : fichiers vifs possédés uniquement.
// Le mot de passe exige 8+ caractères (400 sinon) ; le zip peut être long
// (pas de cap S7 — donnée de l'utilisateur, self-hosté).
func ExportFull(c *gin.Context) {
if Store == nil || Store.Repository == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
var req exportRequest
if err := c.ShouldBindJSON(&req); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body (expected { password })")
return
}
if len(req.Password) < 8 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "password must be at least 8 characters")
return
}
filename := fmt.Sprintf("kazier-export-%s.zip", time.Now().UTC().Format("20060102-150405"))
c.Header("Content-Type", "application/zip")
c.Header("Content-Disposition", "attachment; filename=\""+filename+"\"")
// Erreur mid-stream : headers déjà partis — log + abort (zip tronqué,
// documenté ; le manifest chiffré en fin d'archive manque alors).
if err := Store.Export(c.Writer, userID, req.Password); err != nil {
c.Abort()
return
}
}
+38
View File
@@ -0,0 +1,38 @@
package handlers_test
import (
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// TestExportEndpoint : POST /export exige un mot de passe 8+ (400 sinon) et
// streame un zip (200 + application/zip).
func TestExportEndpoint(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ex"), "export-test-password", device)
for _, body := range []string{`{}`, `{"password":"court"}`, `not-json`} {
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/export", token, []byte(body), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "export-400:"+body)
}
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/export", token, []byte(`{"password":"motdepasse-8"}`), "application/json")
if rec.Code != http.StatusOK {
t.Fatalf("export: attendu 200, got %d %s", rec.Code, rec.Body.String())
}
if ct := rec.Header().Get("Content-Type"); ct != "application/zip" {
t.Fatalf("content-type = %q", ct)
}
if cd := rec.Header().Get("Content-Disposition"); cd == "" {
t.Fatal("content-disposition manquant")
}
if rec.Body.Len() == 0 {
t.Fatal("zip vide")
}
if rec.Body.Bytes()[0] != 'P' || rec.Body.Bytes()[1] != 'K' {
t.Fatal("pas une archive zip (signature PK manquante)")
}
}
+168
View File
@@ -0,0 +1,168 @@
package handlers_test
import (
"encoding/json"
"net/http"
"testing"
"github.com/kazier/backend/repository"
"github.com/kazier/backend/service"
)
// TestFactsEndpoint : GET /files/:id/facts — faits auto visibles (viewer+),
// [] si rien d'extractible, 404 si trashé/absent/étranger.
func TestFactsEndpoint(t *testing.T) {
r, store, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "fa"), "facts-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := repo.Resources.UpdateOcrText(userID, fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil {
t.Fatalf("ocr text: %v", err)
}
extractSvc := service.NewExtract(repo)
if err := extractSvc.ProcessText(userID, fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil {
t.Fatalf("extract: %v", err)
}
_ = store
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/facts", token, nil, "")
env := expectOK(t, rec, "facts-get")
var facts []struct {
FactType string `json:"factType"`
ValueText string `json:"valueText"`
ValueNum *float64 `json:"valueNum"`
Confidence float64 `json:"confidence"`
Origin string `json:"origin"`
}
if err := json.Unmarshal(env.Data, &facts); err != nil {
t.Fatalf("facts unmarshal: %v", err)
}
if len(facts) == 0 {
t.Fatal("faits attendus, got []")
}
types := map[string]bool{}
for _, f := range facts {
types[f.FactType] = true
if f.Origin != "auto" {
t.Errorf("origine = %q, attendu auto", f.Origin)
}
}
for _, want := range []string{"reference", "amount", "date", "doc_type"} {
if !types[want] {
t.Errorf("fait %q manquant: %+v", want, facts)
}
}
// Fichier visible sans faits → [] (200, jamais 404).
emptyID := repository.NewID()
if err := repo.Resources.InsertFile(userID, emptyID, "vide.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert empty: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+emptyID+"/facts", token, nil, "")
env = expectOK(t, rec, "facts-empty")
if string(env.Data) != "[]" {
t.Fatalf("sans faits : attendu [], got %s", env.Data)
}
// Trashé → 404 (comme l'OCR).
if _, err := store.Trash(userID, fileID); err != nil {
t.Fatalf("trash: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/facts", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-trashed")
// Étranger → 404.
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "fb"), "facts-test-password", deviceB)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+emptyID+"/facts", tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-foreign")
}
// TestCorrectFactsEndpoint : PATCH /files/:id/facts — remplace le jeu user
// (editor+ = owner ici), renvoie le jeu complet ; 400 sur corps invalide ;
// 404 si trashé/étranger.
func TestCorrectFactsEndpoint(t *testing.T) {
r, store, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "fc"), "facts-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
extractSvc := service.NewExtract(repo)
if err := extractSvc.ProcessText(userID, fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil {
t.Fatalf("extract: %v", err)
}
_ = store
patch := func(body string) (int, envelope) {
t.Helper()
rec, _ := doRequest(t, r, http.MethodPatch, "/api/v1/files/"+fileID+"/facts", token, []byte(body), "application/json")
var env envelope
if rec.Code == http.StatusOK {
if err := json.Unmarshal(rec.Body.Bytes(), &env); err != nil {
t.Fatalf("patch unmarshal: %v body=%s", err, rec.Body.String())
}
}
return rec.Code, env
}
// Correction : émetteur fixé par l'utilisateur.
code, env := patch(`{"facts":[{"factType":"issuer","valueText":"Vrai Fournisseur","confidence":1}]}`)
if code != http.StatusOK {
t.Fatalf("patch: attendu 200, got %d", code)
}
var facts []struct {
FactType string `json:"factType"`
ValueText string `json:"valueText"`
Origin string `json:"origin"`
}
if err := json.Unmarshal(env.Data, &facts); err != nil {
t.Fatalf("unmarshal: %v", err)
}
foundUser, foundAuto := false, false
for _, f := range facts {
if f.FactType == "issuer" && f.Origin == "user" && f.ValueText == "Vrai Fournisseur" {
foundUser = true
}
if f.Origin == "auto" {
foundAuto = true
}
}
if !foundUser || !foundAuto {
t.Fatalf("jeu après correction inattendu: %+v", facts)
}
// Corps invalides → 400.
for _, body := range []string{
`{}`,
`{"facts":[{"factType":"couleur","valueText":"bleu"}]}`,
`{"facts":[{"factType":"date","valueDate":"12/03/2026"}]}`,
`{"facts":[{"factType":"issuer"}]}`,
`not-json`,
} {
rec, _ := doRequest(t, r, http.MethodPatch, "/api/v1/files/"+fileID+"/facts", token, []byte(body), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "facts-patch-400:"+body)
}
// Étranger (viewer simulé : partage + snapshot hors scope ici, un autre
// user sans grant suffit — CorrectFacts exige editor+) → 404.
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "fd"), "facts-test-password", deviceB)
rec, _ := doRequest(t, r, http.MethodPatch, "/api/v1/files/"+fileID+"/facts", tokenB,
[]byte(`{"facts":[{"factType":"issuer","valueText":"X"}]}`), "application/json")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-patch-foreign")
// Trashé → 404.
if _, err := store.Trash(userID, fileID); err != nil {
t.Fatalf("trash: %v", err)
}
rec, _ = doRequest(t, r, http.MethodPatch, "/api/v1/files/"+fileID+"/facts", token,
[]byte(`{"facts":[{"factType":"issuer","valueText":"X"}]}`), "application/json")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-patch-trashed")
}
+365 -2
View File
@@ -5,9 +5,11 @@ import (
"net/http" "net/http"
"strconv" "strconv"
"strings" "strings"
"time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api" "github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/repository"
"github.com/kazier/backend/service" "github.com/kazier/backend/service"
) )
@@ -107,6 +109,224 @@ func FilesGetOcr(c *gin.Context) {
api.OK(c, dto) api.OK(c, dto)
} }
// FilesGetFacts expose les faits génériques d'un fichier visible (V3 S2) :
// GET /files/:id/facts. Même portée que l'OCR (viewer+, own ou shared) —
// les faits dérivent du texte. `[]` si rien d'extractible (jamais 404 pour
// un fichier visible sans faits) ; 404 si trashé/absent/étranger.
func FilesGetFacts(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
}
facts, err := Store.GetFacts(userID, id)
if err != nil {
writeError(c, err)
return
}
if facts == nil {
facts = []service.FactDTO{}
}
api.OK(c, facts)
}
// FilesCorrectFacts remplace le jeu `user` des faits (V3 S3) :
// PATCH /files/:id/facts `{ facts: [...] }` (full-replace, jamais de diff).
// Nécessite editor+ (comme update_metadata) ; viewer- → 404 NOT_FOUND.
// Corps invalide (type inconnu, date non ISO, fait sans valeur) → 400.
func FilesCorrectFacts(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
}
var req struct {
Facts []service.FactDTO `json:"facts"`
}
if err := c.ShouldBindJSON(&req); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body (expected { facts: [...] })")
return
}
if req.Facts == nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "missing required field `facts`")
return
}
if len(req.Facts) > 100 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "`facts` too long (max 100)")
return
}
if err := Store.CorrectFacts(userID, id, req.Facts); err != nil {
// Erreurs de validation (type/date/valeur) → 400 explicite, pas 500 :
// ce sont des fautes client, jamais des pannes (cf. FEEDBACK #8).
if errors.Is(err, service.ErrInvalidFact) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
return
}
writeError(c, err)
return
}
facts, err := Store.GetFacts(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, facts)
}
// RelationsList expose le graphe documentaire d'une ressource possédée
// (V3 S5) : `GET /files/:id/relations`. Réconcilie d'abord (les arêtes
// déterministes convergent à la lecture), puis renvoie les arêtes vivantes
// (l'autre bout non trashé), confiance décroissante. Owner-only : le graphe
// d'autrui ne s'énumère pas (404, comme `/shares`).
func RelationsList(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
}
relations, err := Store.ListRelations(userID, id)
if err != nil {
writeError(c, err)
return
}
if relations == nil {
relations = []service.RelationDTO{}
}
api.OK(c, relations)
}
// RelationVerdict enregistre un verdict explicite sur une arête (V3 S5) :
// `POST /files/:id/relations/verdict { otherId, linkType, confirmed }`.
// Confirmé → 1.0, infirmé → 0.0 (conservé, bloque la re-création auto).
// Owner-only, les deux bouts possédés et vifs, sinon 404 ; type/paire
// invalide → 400.
func RelationVerdict(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
}
var req struct {
OtherID string `json:"otherId"`
LinkType string `json:"linkType"`
Confirmed bool `json:"confirmed"`
}
if err := c.ShouldBindJSON(&req); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body (expected { otherId, linkType, confirmed })")
return
}
if !deviceIDPattern.MatchString(req.OtherID) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `otherId` (32 lowercase hex)")
return
}
if err := Store.LinkVerdict(userID, id, req.OtherID, req.LinkType, req.Confirmed); err != nil {
if errors.Is(err, service.ErrInvalidLinkType) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
return
}
writeError(c, err)
return
}
relations, err := Store.ListRelations(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, relations)
}
// DuplicatesList expose les doublons d'octets du compte (V3 S5 B2) :
// `GET /duplicates`. Groupes par hash, plus gros d'abord, avec le gain
// récupérable (« garder un seul »). Scope owner — `[]` quand propre.
func DuplicatesList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
groups, err := Store.ListDuplicates(userID)
if err != nil {
writeError(c, err)
return
}
api.OK(c, groups)
}
// 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)
}
// FilesPreview sert la vignette JPEG d'un fichier visible (V3 S7) :
// `GET /files/:id/preview` (binaire brut, hors enveloppe, `inline`).
// Générée à la demande (images pur Go, PDF page 1 via `pdftoppm`) et cachée
// jusqu'au prochain changement (taille/`updated_at`). 404 NOT_FOUND si
// invisible/metadata-only (indistinguables, pas d'énumération), 404
// NO_PREVIEW si le type ne se prévisualise pas (l'UI montre l'icône).
func FilesPreview(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
}
path, err := Store.OpenPreview(userID, id)
if err != nil {
writeError(c, err)
return
}
c.Header("Content-Type", "image/jpeg")
c.Header("Content-Disposition", "inline; filename=\""+id+".jpg\"")
c.Header("Cache-Control", "private, max-age=3600")
c.File(path)
}
func FilesDelete(c *gin.Context) { func FilesDelete(c *gin.Context) {
if Store == nil { if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -118,7 +338,19 @@ func FilesDelete(c *gin.Context) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found") api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return return
} }
deletedID, err := Store.DeleteFile(userID, id) // V3 corbeille : DELETE = trash par défaut ; ?mode=purge = destruction
// définitive (lignes + versions + octets). Mode inconnu → 400.
var deletedID string
var err error
switch c.Query("mode") {
case "", "trash":
deletedID, err = Store.Trash(userID, id)
case "purge":
deletedID, err = Store.Purge(userID, id)
default:
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `mode` (trash|purge)")
return
}
if err != nil { if err != nil {
writeError(c, err) writeError(c, err)
return return
@@ -126,6 +358,94 @@ func FilesDelete(c *gin.Context) {
api.OK(c, gin.H{"id": deletedID}) api.OK(c, gin.H{"id": deletedID})
} }
// FilesRestore restaure une ressource trashée (POST /files/:id/restore).
// Absente/étrangère → 404 NOT_FOUND ; déjà vivante → succès idempotent.
func FilesRestore(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
}
restoredID, err := Store.Restore(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": restoredID})
}
// TrashList expose la corbeille (GET /trash) : ressources trashées du user,
// les plus récentes d'abord, paginé comme les autres listes.
func TrashList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
page, pageSize, ok := parsePageParams(c)
if !ok {
return
}
items, total, err := Store.ListTrashed(userID, page, pageSize)
if err != nil {
writeError(c, err)
return
}
api.OKList(c, items, page, pageSize, total)
}
// VersionsList expose l'historique des octets (GET /files/:id/versions),
// le plus récent d'abord. Ressource trashée/absente/étrangère → 404.
func VersionsList(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
}
versions, err := Store.ListVersions(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, versions)
}
// VersionRestore recopie la génération n vers le live
// (POST /files/:id/versions/:n/restore). Génération inconnue → 404.
func VersionRestore(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
}
n, err := strconv.Atoi(c.Param("n"))
if err != nil || n < 1 {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "version not found")
return
}
dto, err := Store.RestoreVersion(userID, id, n)
if err != nil {
writeError(c, err)
return
}
api.OK(c, dto)
}
func FilesUpload(c *gin.Context) { func FilesUpload(c *gin.Context) {
if Store == nil { if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
@@ -208,10 +528,53 @@ func FilesSearch(c *gin.Context) {
if !ok { if !ok {
return return
} }
files, total, err := Store.SearchFiles(userID, q, page, pageSize) facets, ok := parseSearchFacets(c)
if !ok {
return
}
files, total, err := Store.SearchFiles(userID, q, page, pageSize, facets)
if err != nil { if err != nil {
writeError(c, err) writeError(c, err)
return return
} }
api.OKList(c, files, page, pageSize, total) api.OKList(c, files, page, pageSize, total)
} }
// parseSearchFacets lit les facettes V3 (`issuer`, `from`/`to` ISO,
// `min_amount`/`max_amount` numériques, `doc_type`) — 400 si malformées.
func parseSearchFacets(c *gin.Context) (repository.SearchFacets, bool) {
var facets repository.SearchFacets
facets.Issuer = strings.TrimSpace(c.Query("issuer"))
facets.DocType = strings.TrimSpace(c.Query("doc_type"))
if v := strings.TrimSpace(c.Query("from")); v != "" {
if _, err := time.Parse("2006-01-02", v); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `from` must be ISO YYYY-MM-DD")
return facets, false
}
facets.From = v
}
if v := strings.TrimSpace(c.Query("to")); v != "" {
if _, err := time.Parse("2006-01-02", v); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `to` must be ISO YYYY-MM-DD")
return facets, false
}
facets.To = v
}
if v := strings.TrimSpace(c.Query("min_amount")); v != "" {
f, err := strconv.ParseFloat(strings.ReplaceAll(v, ",", "."), 64)
if err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `min_amount` must be numeric")
return facets, false
}
facets.MinAmount = &f
}
if v := strings.TrimSpace(c.Query("max_amount")); v != "" {
f, err := strconv.ParseFloat(strings.ReplaceAll(v, ",", "."), 64)
if err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `max_amount` must be numeric")
return facets, false
}
facets.MaxAmount = &f
}
return facets, true
}
+357
View File
@@ -7,6 +7,8 @@ import (
"mime/multipart" "mime/multipart"
"net/http" "net/http"
"net/http/httptest" "net/http/httptest"
"os"
"path/filepath"
"testing" "testing"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@@ -74,6 +76,7 @@ func setup(t *testing.T) (*gin.Engine, *service.Resources, *repository.Repositor
handlers.Auth = manager handlers.Auth = manager
handlers.Store = store handlers.Store = store
handlers.ResetDevicesRateLimit() handlers.ResetDevicesRateLimit()
handlers.ResetLoginRateLimit()
gin.SetMode(gin.TestMode) gin.SetMode(gin.TestMode)
r := gin.New() r := gin.New()
@@ -357,6 +360,83 @@ func TestSearchFiles(t *testing.T) {
} }
} }
// TestSearchFacets : filtres V3 sur faits + 400 si malformés.
func TestSearchFacets(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, user := registerAndLogin(t, r, repo, testUserUsername(device, "sf"), "search-test-password", device)
edfID := repository.NewID()
if err := repo.Resources.InsertFile(user, edfID, "scan_1.pdf", "", 100, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := repo.Resources.UpdateOcrText(user, edfID, "Facture EDF de mars"); err != nil {
t.Fatalf("ocr: %v", err)
}
num := 84.20
if err := repo.Resources.UpsertAutoFacts(edfID, []repository.FactParam{
{Type: "issuer", ValueText: "EDF", Confidence: 0.9},
{Type: "amount", ValueText: "84.20 €", ValueNum: &num, Confidence: 0.9},
{Type: "doc_type", ValueText: "facture", Confidence: 0.8},
}); err != nil {
t.Fatalf("facts: %v", err)
}
otherID := repository.NewID()
if err := repo.Resources.InsertFile(user, otherID, "scan_2.pdf", "", 100, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
get := func(query string) []fileDTO {
t.Helper()
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search"+query, token, nil, "")
env := expectOK(t, rec, "search-facets:"+query)
var files []fileDTO
if err := json.Unmarshal(env.Data, &files); err != nil {
t.Fatalf("unmarshal %s: %v", query, err)
}
return files
}
// FTS via OCR (nom opaque).
if files := get("?q=EDF"); len(files) == 0 || files[0].ID != edfID {
t.Errorf("q=EDF via OCR: %+v", files)
}
// Facette émetteur : filtre.
if files := get("?q=facture&issuer=edf"); len(files) != 1 || files[0].ID != edfID {
t.Errorf("issuer=edf: %+v", files)
}
if files := get("?q=facture&issuer=engie"); len(files) != 0 {
t.Errorf("issuer=engie doit filtrer: %+v", files)
}
// Facette montant.
if files := get("?q=facture&min_amount=100"); len(files) != 0 {
t.Errorf("min_amount=100 doit exclure 84.20: %+v", files)
}
if files := get("?q=facture&max_amount=100"); len(files) != 1 {
t.Errorf("max_amount=100: %+v", files)
}
// Facette doc_type.
if files := get("?q=scan&doc_type=facture"); len(files) != 1 || files[0].ID != edfID {
t.Errorf("doc_type=facture: %+v", files)
}
// Malformées → 400.
for _, query := range []string{
"?q=facture&from=12/03/2026",
"?q=facture&to=demain",
"?q=facture&min_amount=beaucoup",
"?q=facture&max_amount=",
} {
// max_amount vide = absent (pas d'erreur) — seul le cas non-vide
// non-numérique est rejeté ; on l'exclut ici.
if query == "?q=facture&max_amount=" {
continue
}
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search"+query, token, nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-facets-400:"+query)
}
}
func TestSearchFilesEscapesPercent(t *testing.T) { func TestSearchFilesEscapesPercent(t *testing.T) {
r, _, repo := setup(t) r, _, repo := setup(t)
device := repository.NewID() device := repository.NewID()
@@ -686,3 +766,280 @@ func TestSearchQTooLong(t *testing.T) {
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "") 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") 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")
}
+9 -1
View File
@@ -60,7 +60,7 @@ func RequireAuth(c *gin.Context) {
// Le store peut être nil dans les tests middleware purs ; sinon on vérifie // Le store peut être nil dans les tests middleware purs ; sinon on vérifie
// que le compte existe toujours (supprimé → accès refusé). // que le compte existe toujours (supprimé → accès refusé).
if Store != nil && Store.Repository != nil { if Store != nil && Store.Repository != nil {
_, err := Store.Repository.Users.GetByID(identity.UserID) user, err := Store.Repository.Users.GetByID(identity.UserID)
if errors.Is(err, repository.ErrNotFound) { if errors.Is(err, repository.ErrNotFound) {
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "account no longer exists") api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "account no longer exists")
c.Abort() c.Abort()
@@ -71,6 +71,14 @@ func RequireAuth(c *gin.Context) {
c.Abort() c.Abort()
return return
} }
// V3 S6 : révocation — un changement de mot de passe (bump de
// token_version) invalide tous les tokens antérieurs, même non expirés.
if identity.TokenVersion != user.TokenVersion {
log.Printf("auth: token révoqué rejeté (user=%s tv=%d, attendu %d)", identity.UserID, identity.TokenVersion, user.TokenVersion)
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "token revoked")
c.Abort()
return
}
} }
if EnforceDeviceExists && Store != nil && Store.Repository != nil { if EnforceDeviceExists && Store != nil && Store.Repository != nil {
+108
View File
@@ -0,0 +1,108 @@
package handlers_test
import (
"bytes"
"image"
"image/color"
"image/jpeg"
"net/http"
"os"
"path/filepath"
"strings"
"testing"
"github.com/kazier/backend/repository"
)
// previewImageBytes génère un JPEG 640x480 uni (décodable sans fixture).
func previewImageBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 640, 480))
for y := 0; y < 480; y++ {
for x := 0; x < 640; x++ {
img.Set(x, y, color.RGBA{uint8(x % 256), 128, 64, 255})
}
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, nil); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
// TestFilesPreview : JPEG 200 + image/jpeg pour une image, NO_PREVIEW pour
// un txt, NOT_FOUND si trashé/étranger. L'upload HTTP de test est capé à
// 10 o : le physique est écrit directement (même layout UPLOAD_DIR).
func TestFilesPreview(t *testing.T) {
r, store, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "pv"), "preview-test-password", device)
createdID := seedPhysical(t, store.UploadDir, repo, userID, "photo.jpg", previewImageBytes(t))
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+createdID+"/preview", token, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("preview: attendu 200, got %d %s", rec.Code, rec.Body.String())
}
if ct := rec.Header().Get("Content-Type"); ct != "image/jpeg" {
t.Fatalf("content-type = %q, attendu image/jpeg", ct)
}
if _, err := jpeg.Decode(bytes.NewReader(rec.Body.Bytes())); err != nil {
t.Fatalf("corps non-JPEG: %v", err)
}
// Txt → NO_PREVIEW (404 typé, l'UI montre l'icône).
txtID := seedPhysical(t, store.UploadDir, repo, userID, "notes.txt", []byte("hello"))
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+txtID+"/preview", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NO_PREVIEW", "preview-txt")
// Trashé → NOT_FOUND (invisible d'abord, pas NO_PREVIEW).
if err := repo.Resources.TrashResource(userID, createdID); err != nil {
t.Fatalf("trash: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+createdID+"/preview", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "preview-trashed")
// Étranger → NOT_FOUND.
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "pb"), "preview-test-password", deviceB)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+txtID+"/preview", tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "preview-foreign")
}
// seedPhysical insère la métadonnée + écrit les octets (même layout que
// l'upload, sans passer par le multipart capé des tests).
func seedPhysical(t *testing.T, uploadDir string, repo *repository.Repository, userID, name string, content []byte) string {
t.Helper()
id := repository.NewID()
ext := ""
if i := strings.LastIndex(name, "."); i >= 0 {
ext = name[i+1:]
}
var extPtr *string
if ext != "" {
extPtr = &ext
}
mime := "application/octet-stream"
if ext == "jpg" {
mime = "image/jpeg"
}
if err := repo.Resources.InsertFile(userID, id, name, "", int64(len(content)), &mime, extPtr); err != nil {
t.Fatalf("insert: %v", err)
}
dir := filepath.Join(uploadDir, userID)
if err := os.MkdirAll(dir, 0o700); err != nil {
t.Fatalf("mkdir: %v", err)
}
dest := id
if ext != "" {
dest = id + "." + ext
}
if err := os.WriteFile(filepath.Join(dir, dest), content, 0o600); err != nil {
t.Fatalf("write: %v", err)
}
if err := repo.Resources.SetHasContent(userID, id, true); err != nil {
t.Fatalf("has_content: %v", err)
}
return id
}
+93
View File
@@ -0,0 +1,93 @@
package handlers_test
import (
"encoding/json"
"fmt"
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// TestRelationsEndpoints : GET /files/:id/relations (réconciliation à la
// lecture) + POST verdict (confirmé/infirmé, 400/404).
func TestRelationsEndpoints(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "rl"), "relations-test-password", device)
session := repository.NewID()
page1, page2 := repository.NewID(), repository.NewID()
for _, id := range []string{page1, page2} {
if err := repo.Resources.InsertFile(userID, id, id+".png", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := repo.Resources.SetScanSession(userID, id, session); err != nil {
t.Fatalf("session: %v", err)
}
}
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+page1+"/relations", token, nil, "")
env := expectOK(t, rec, "relations-get")
var rels []struct {
ID string `json:"id"`
OtherID string `json:"otherId"`
Type string `json:"type"`
Confidence float64 `json:"confidence"`
CreatedBy string `json:"createdBy"`
OtherName string `json:"otherName"`
}
if err := json.Unmarshal(env.Data, &rels); err != nil {
t.Fatalf("unmarshal: %v", err)
}
if len(rels) != 1 || rels[0].Type != "same_scan" || rels[0].OtherID != page2 {
t.Fatalf("relations inattendues: %+v", rels)
}
// Verdict infirmé : arête conservée à 0.0, origine user.
body := fmt.Sprintf(`{"otherId":%q,"linkType":"same_scan","confirmed":false}`, page2)
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+page1+"/relations/verdict", token, []byte(body), "application/json")
env = expectOK(t, rec, "relations-verdict")
rels = nil
if err := json.Unmarshal(env.Data, &rels); err != nil {
t.Fatalf("unmarshal verdict: %v", err)
}
if len(rels) != 1 || rels[0].Confidence != 0 || rels[0].CreatedBy != "user" {
t.Fatalf("verdict inattendu: %+v", rels)
}
// Type inconnu → 400 ; paire non-hex → 400 ; étranger → 404.
for _, tc := range []struct {
name, body string
status int
code string
}{
{"type", fmt.Sprintf(`{"otherId":%q,"linkType":"copains","confirmed":true}`, page2), http.StatusBadRequest, "INVALID_REQUEST"},
{"hex", `{"otherId":"nope","linkType":"same_scan","confirmed":true}`, http.StatusBadRequest, "INVALID_REQUEST"},
} {
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+page1+"/relations/verdict", token, []byte(tc.body), "application/json")
expectError(t, rec, tc.status, tc.code, "relations-verdict-400:"+tc.name)
}
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "rb"), "relations-test-password", deviceB)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+page1+"/relations", tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "relations-foreign")
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+page1+"/relations/verdict", tokenB,
[]byte(fmt.Sprintf(`{"otherId":%q,"linkType":"same_scan","confirmed":true}`, page2)), "application/json")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "relations-verdict-foreign")
// Trashé → 404 (l'autre bout trashé disparaît aussi de la liste).
if err := repo.Resources.TrashResource(userID, page2); err != nil {
t.Fatalf("trash: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+page1+"/relations", token, nil, "")
env = expectOK(t, rec, "relations-trashed-other")
rels = nil
if err := json.Unmarshal(env.Data, &rels); err != nil {
t.Fatalf("unmarshal: %v", err)
}
if len(rels) != 0 {
t.Fatalf("bout trashé encore listé: %+v", rels)
}
}
+26
View File
@@ -33,11 +33,37 @@ func RegisterRoutes(r *gin.Engine) {
protected.GET("/files/folders", FoldersList) protected.GET("/files/folders", FoldersList)
protected.GET("/files/:id", FilesGet) protected.GET("/files/:id", FilesGet)
protected.GET("/files/:id/ocr", FilesGetOcr) protected.GET("/files/:id/ocr", FilesGetOcr)
protected.GET("/files/:id/facts", FilesGetFacts)
protected.PATCH("/files/:id/facts", FilesCorrectFacts)
protected.GET("/files/:id/content", FilesContent)
protected.GET("/files/:id/preview", FilesPreview)
protected.GET("/files/:id/shares", SharesList)
protected.GET("/files/:id/links", LinksList)
protected.GET("/files/:id/placements", PlacementsList)
protected.GET("/files/:id/versions", VersionsList)
protected.GET("/files/:id/relations", RelationsList)
protected.POST("/files/:id/relations/verdict", RelationVerdict)
protected.GET("/duplicates", DuplicatesList)
protected.POST("/export", ExportFull)
protected.POST("/files/:id/restore", FilesRestore)
protected.POST("/files/:id/versions/:n/restore", VersionRestore)
protected.GET("/trash", TrashList)
protected.DELETE("/files/:id", FilesDelete) protected.DELETE("/files/:id", FilesDelete)
protected.POST("/files/upload", FilesUpload) protected.POST("/files/upload", FilesUpload)
protected.GET("/users/resolve", ResolveUser) protected.GET("/users/resolve", ResolveUser)
protected.PATCH("/users/me/password", ChangePassword) protected.PATCH("/users/me/password", ChangePassword)
protected.GET("/users/me/usage", UsersUsage)
protected.GET("/devices", DevicesList)
protected.DELETE("/devices/:id", DeviceRevoke)
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.POST("/ocr/jobs", OcrJobsCreate)
protected.GET("/ocr/jobs/:id", OcrJobsGet) protected.GET("/ocr/jobs/:id", OcrJobsGet)
+152
View File
@@ -0,0 +1,152 @@
package handlers_test
import (
"encoding/json"
"fmt"
"net/http"
"testing"
"github.com/kazier/backend/handlers"
"github.com/kazier/backend/repository"
)
// TestPasswordChangeRevokesTokens : le bump de token_version invalide tous
// les tokens antérieurs (V3 S6) — l'ancien token devient 401, un nouveau
// login fonctionne.
func TestPasswordChangeRevokesTokens(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "rv"), "revoke-test-password", device)
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("token initial rejeté: %d %s", rec.Code, rec.Body.String())
}
body := `{"current_password":"revoke-test-password","new_password":"revoke-test-password-2"}`
rec, _ = doRequest(t, r, http.MethodPatch, "/api/v1/users/me/password", token, []byte(body), "application/json")
expectOK(t, rec, "password-change")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "")
expectError(t, rec, http.StatusUnauthorized, "UNAUTHORIZED", "revoked-token")
// Nouveau login (nouvelle version) : fonctionne.
body = fmt.Sprintf(`{"username":%q,"password":"revoke-test-password-2","device_id":%q}`,
testUserUsername(device, "rv"), device)
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/auth/login", "", []byte(body), "application/json")
expectOK(t, rec, "relogin")
var login struct {
Data struct {
Token string `json:"token"`
} `json:"data"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &login); err != nil || login.Data.Token == "" {
t.Fatalf("relogin sans token: %s", rec.Body.String())
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", login.Data.Token, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("nouveau token rejeté: %d %s", rec.Code, rec.Body.String())
}
}
// TestDevicesListAndRevoke : liste les devices du compte, révoque (A1) —
// avec EnforceDeviceExists, le token du device révoqué devient 401 et son
// login est refusé (ré-enregistrement requis).
func TestDevicesListAndRevoke(t *testing.T) {
r, _, repo := setup(t)
handlers.EnforceDeviceExists = true
defer func() { handlers.EnforceDeviceExists = false }()
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "dv"), "devices-test-password", device)
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/devices", token, nil, "")
env := expectOK(t, rec, "devices-list")
var devices []struct {
DeviceID string `json:"deviceId"`
LastSeenAt *int64 `json:"lastSeenAt"`
}
if err := json.Unmarshal(env.Data, &devices); err != nil {
t.Fatalf("unmarshal: %v", err)
}
found := false
for _, d := range devices {
if d.DeviceID == device {
found = true
}
}
if !found {
t.Fatalf("device absent de la liste: %+v", devices)
}
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/devices/"+device, token, nil, "")
expectOK(t, rec, "devices-revoke")
// Token existant → 401 (device inconnu).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "")
expectError(t, rec, http.StatusUnauthorized, "UNAUTHORIZED", "revoked-device-token")
// Login refusé (device inconnu, indistinguable — 401).
body := fmt.Sprintf(`{"username":%q,"password":"devices-test-password","device_id":%q}`,
testUserUsername(device, "dv"), device)
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/auth/login", "", []byte(body), "application/json")
expectError(t, rec, http.StatusUnauthorized, "UNAUTHORIZED", "revoked-device-login")
// Révoquer l'inexistant / malformé → 404 (avec un token encore valide).
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "dv2"), "devices-test-password", deviceB)
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/devices/"+repository.NewID(), tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "revoke-unknown")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/devices/nope", tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "revoke-malformed")
}
// TestUsageAndQuota : GET /users/me/usage reflète l'état, et un upload
// au-delà du quota est rejeté en 413 QUOTA_EXCEEDED (V3 S6 A2).
func TestUsageAndQuota(t *testing.T) {
r, store, repo := setup(t)
_ = store
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "qu"), "quota-test-password", device)
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/users/me/usage", token, nil, "")
env := expectOK(t, rec, "usage-empty")
var usage struct {
UsedBytes int64 `json:"usedBytes"`
QuotaBytes int64 `json:"quotaBytes"`
FileCount int `json:"fileCount"`
TrashCount int `json:"trashCount"`
TrashedBytes int64 `json:"trashedBytes"`
}
if err := json.Unmarshal(env.Data, &usage); err != nil {
t.Fatalf("unmarshal: %v", err)
}
if usage.UsedBytes != 0 || usage.QuotaBytes != 10737418240 || usage.FileCount != 0 {
t.Fatalf("usage initial inattendu: %+v", usage)
}
// Quota miniature (10 octets) → l'upload passe sous le seuil puis casse.
if _, err := repo.Users.DB.Exec(`UPDATE users SET storage_quota_bytes = 10 WHERE id = $1`, userID); err != nil {
t.Fatalf("shrink quota: %v", err)
}
rec = uploadMultipart(t, r, token, "", "a.txt", []byte("12345"))
expectOK(t, rec, "usage-under-quota")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/users/me/usage", token, nil, "")
env = expectOK(t, rec, "usage-after")
usage = struct {
UsedBytes int64 `json:"usedBytes"`
QuotaBytes int64 `json:"quotaBytes"`
FileCount int `json:"fileCount"`
TrashCount int `json:"trashCount"`
TrashedBytes int64 `json:"trashedBytes"`
}{}
if err := json.Unmarshal(env.Data, &usage); err != nil {
t.Fatalf("unmarshal: %v", err)
}
if usage.UsedBytes != 5 || usage.FileCount != 1 {
t.Fatalf("usage après upload: %+v", usage)
}
rec = uploadMultipart(t, r, token, "", "b.txt", []byte("123456"))
expectError(t, rec, http.StatusRequestEntityTooLarge, "QUOTA_EXCEEDED", "usage-over-quota")
}
+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)
}
+6
View File
@@ -24,10 +24,16 @@ func writeError(c *gin.Context, err error) {
api.Error(c, 404, "NOT_FOUND", "resource not found") api.Error(c, 404, "NOT_FOUND", "resource not found")
case errors.Is(err, repository.ErrGranteeNotFound): case errors.Is(err, repository.ErrGranteeNotFound):
api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist") api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist")
case errors.Is(err, repository.ErrGroupNotFound):
api.Error(c, 404, "GROUP_NOT_FOUND", "the specified group does not exist")
case errors.Is(err, repository.ErrNameConflict): case errors.Is(err, repository.ErrNameConflict):
api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here") api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here")
case errors.Is(err, service.ErrFileTooLarge): case errors.Is(err, service.ErrFileTooLarge):
api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size") api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size")
case errors.Is(err, service.ErrQuotaExceeded):
api.Error(c, 413, "QUOTA_EXCEEDED", "storage quota exceeded")
case errors.Is(err, service.ErrNoPreview):
api.Error(c, 404, "NO_PREVIEW", "no preview available for this file")
default: default:
// Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf. // Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf.
// FEEDBACK #8) : message générique, détail au log serveur. // FEEDBACK #8) : message générique, détail au log serveur.
+160
View File
@@ -0,0 +1,160 @@
package handlers_test
import (
"encoding/json"
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// TestTrashEndpoints couvre le cycle corbeille via HTTP : DELETE (trash) →
// 404 en lecture → GET /trash → POST /files/:id/restore → visible →
// DELETE ?mode=purge → corbeille vide, restore → 404.
func TestTrashEndpoints(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "tr"), "trash-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "acte.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, token, nil, "")
expectOK(t, rec, "trash-delete")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-get-hidden")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", token, nil, "")
env := expectOK(t, rec, "trash-list")
var items []struct {
ID string `json:"id"`
Type string `json:"type"`
TrashedAt string `json:"trashedAt"`
}
if err := json.Unmarshal(env.Data, &items); err != nil {
t.Fatalf("trash list unmarshal: %v", err)
}
if len(items) != 1 || items[0].ID != fileID || items[0].TrashedAt == "" {
t.Fatalf("corbeille inattendue: %+v", items)
}
if env.Meta == nil || env.Meta.Total != 1 {
t.Fatalf("meta corbeille: %+v", env.Meta)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+fileID+"/restore", token, nil, "")
expectOK(t, rec, "trash-restore")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "")
expectOK(t, rec, "trash-get-restored")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID+"?mode=purge", token, nil, "")
expectOK(t, rec, "trash-purge")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", token, nil, "")
env = expectOK(t, rec, "trash-list-empty")
if env.Meta == nil || env.Meta.Total != 0 {
t.Fatalf("corbeille doit être vide: %+v", env.Meta)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+fileID+"/restore", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-restore-purged")
}
// TestTrashInvalidMode : ?mode inconnu → 400, la ressource reste vivante.
func TestTrashInvalidMode(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "tm"), "trash-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID+"?mode=bogus", token, nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "trash-bad-mode")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "")
expectOK(t, rec, "trash-bad-mode-keeps-live")
}
// TestTrashIsolation : un user ne voit ni ne touche la corbeille d'autrui.
func TestTrashIsolation(t *testing.T) {
r, _, repo := setup(t)
deviceA := repository.NewID()
deviceB := repository.NewID()
tokenA, userA := registerAndLogin(t, r, repo, testUserUsername(deviceA, "ta"), "trash-test-password", deviceA)
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "tb"), "trash-test-password", deviceB)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userA, fileID, "prive.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-foreign")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", tokenB, nil, "")
env := expectOK(t, rec, "trash-foreign-list")
if env.Meta == nil || env.Meta.Total != 0 {
t.Fatalf("corbeille d'autrui doit être vide: %+v", env.Meta)
}
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, tokenA, nil, "")
expectOK(t, rec, "trash-owner")
}
// TestVersionsEndpoints : upload miniature (MaxFileSize=10 en test) puis
// re-upload ciblé → GET /files/:id/versions (1 entrée) → restore → contenu
// d'origine. Trashée → versions en 404.
func TestVersionsEndpoints(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ve"), "trash-test-password", device)
rec := uploadMultipart(t, r, token, "", "doc.txt", []byte("AAA"))
env := expectOK(t, rec, "versions-upload")
var created fileDTO
if err := json.Unmarshal(env.Data, &created); err != nil {
t.Fatalf("upload unmarshal: %v", err)
}
rec = uploadMultipartToResource(t, r, token, created.ID, "doc.txt", []byte("BBBB"))
expectOK(t, rec, "versions-overwrite")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+created.ID+"/versions", token, nil, "")
env = expectOK(t, rec, "versions-list")
var vers []struct {
VersionNo int `json:"versionNo"`
Size int64 `json:"size"`
CreatedAt string `json:"createdAt"`
}
if err := json.Unmarshal(env.Data, &vers); err != nil {
t.Fatalf("versions unmarshal: %v", err)
}
if len(vers) != 1 || vers[0].Size != 3 {
t.Fatalf("versions inattendues: %+v", vers)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+created.ID+"/versions/1/restore", token, nil, "")
env = expectOK(t, rec, "versions-restore")
var restored fileDTO
if err := json.Unmarshal(env.Data, &restored); err != nil {
t.Fatalf("restore unmarshal: %v", err)
}
if restored.Size != 3 {
t.Fatalf("live restauré taille=%d, attendu 3", restored.Size)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+created.ID+"/versions/99/restore", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "versions-restore-unknown")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+created.ID, token, nil, "")
expectOK(t, rec, "versions-trash")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+created.ID+"/versions", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "versions-trashed-hidden")
}
+25
View File
@@ -0,0 +1,25 @@
package handlers
import (
"net/http"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
)
// UsersUsage expose l'empreinte du compte (V3 S6 A2) : `GET /users/me/usage`
// `{ usedBytes, quotaBytes, fileCount, trashCount, trashedBytes }` —
// calculé, jamais stocké. La corbeille est détaillée (octets récupérables).
func UsersUsage(c *gin.Context) {
if Store == nil || Store.Repository == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
usage, err := Store.Usage(userID)
if err != nil {
writeError(c, err)
return
}
api.OK(c, usage)
}
+28 -12
View File
@@ -4,6 +4,7 @@ import (
"crypto/sha256" "crypto/sha256"
"errors" "errors"
"regexp" "regexp"
"strconv"
"time" "time"
"aidanwoods.dev/go-paseto" "aidanwoods.dev/go-paseto"
@@ -17,11 +18,14 @@ var ErrInvalidToken = errors.New("invalid token")
var hex32Pattern = regexp.MustCompile(`^[0-9a-f]{32}$`) var hex32Pattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
// Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant) // Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant),
// et le device (claim secondaire, porté mais NON autorisant seul). // le device (claim secondaire, porté mais NON autorisant seul) et la version
// de révocation (claim `tv`, V3 S6 — le middleware la compare à
// users.token_version).
type Identity struct { type Identity struct {
UserID string UserID string
DeviceID string DeviceID string
TokenVersion int
} }
// Manager issues and verifies paseto v4-local bearer tokens. // Manager issues and verifies paseto v4-local bearer tokens.
@@ -40,16 +44,19 @@ func NewManager(secret string) (*Manager, error) {
return &Manager{key: key}, nil return &Manager{key: key}, nil
} }
// Issue émet un token lié à un utilisateur ET à un device. // Issue émet un token lié à un utilisateur ET à un device (version 0 —
// compat pré-V3, cf. IssueWithExpiry).
func (m *Manager) Issue(userID, deviceID string) (string, error) { func (m *Manager) Issue(userID, deviceID string) (string, error) {
token, _, err := m.IssueWithExpiry(userID, deviceID) token, _, err := m.IssueWithExpiry(userID, deviceID, 0)
return token, err return token, err
} }
// IssueWithExpiry émet un token et retourne son expiration réelle (le `exp` // IssueWithExpiry émet un token et retourne son expiration réelle (le `exp`
// embarqué). Les appelants doivent exposer expiresAt, jamais le recalculer // embarqué). Les appelants doivent exposer expiresAt, jamais le recalculer
// via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7). // via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7). `tokenVersion` est le
func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, error) { // compteur de révocation du compte (V3 S6) — bumpé à chaque changement de
// mot de passe, vérifié par le middleware.
func (m *Manager) IssueWithExpiry(userID, deviceID string, tokenVersion int) (string, time.Time, error) {
now := time.Now() now := time.Now()
expiresAt := now.Add(TokenTTL) expiresAt := now.Add(TokenTTL)
token := paseto.NewToken() token := paseto.NewToken()
@@ -59,12 +66,14 @@ func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, e
token.SetSubject(userID) token.SetSubject(userID)
// v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable). // v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable).
token.SetString("device_id", deviceID) token.SetString("device_id", deviceID)
token.SetString("tv", strconv.Itoa(tokenVersion))
return token.V4Encrypt(m.key, nil), expiresAt, nil return token.V4Encrypt(m.key, nil), expiresAt, nil
} }
// Verify décode et contrôle le token, retourne l'identité (user + device). // Verify décode et contrôle le token, retourne l'identité (user + device +
// Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) — rejet // version). Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) —
// sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK. // rejet sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK.
// `tv` absent (tokens pré-V3) → 0 ; non numérique → rejet.
func (m *Manager) Verify(signed string) (Identity, error) { func (m *Manager) Verify(signed string) (Identity, error) {
parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil)
if err != nil { if err != nil {
@@ -78,5 +87,12 @@ func (m *Manager) Verify(signed string) (Identity, error) {
if err != nil || !hex32Pattern.MatchString(deviceID) { if err != nil || !hex32Pattern.MatchString(deviceID) {
return Identity{}, ErrInvalidToken return Identity{}, ErrInvalidToken
} }
return Identity{UserID: userID, DeviceID: deviceID}, nil tv := 0
if raw, err := parsed.GetString("tv"); err == nil && raw != "" {
tv, err = strconv.Atoi(raw)
if err != nil || tv < 0 {
return Identity{}, ErrInvalidToken
}
}
return Identity{UserID: userID, DeviceID: deviceID, TokenVersion: tv}, nil
} }
+25 -1
View File
@@ -159,7 +159,7 @@ func TestIssueSetsExpiration(t *testing.T) {
func TestIssueWithExpiryMatchesTokenExp(t *testing.T) { func TestIssueWithExpiryMatchesTokenExp(t *testing.T) {
m, _ := NewManager("test-secret") m, _ := NewManager("test-secret")
signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID) signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID, 3)
if err != nil { if err != nil {
t.Fatalf("IssueWithExpiry: %v", err) t.Fatalf("IssueWithExpiry: %v", err)
} }
@@ -177,4 +177,28 @@ func TestIssueWithExpiryMatchesTokenExp(t *testing.T) {
if exp.Unix() != expiresAt.Unix() { if exp.Unix() != expiresAt.Unix() {
t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp) t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp)
} }
id, err := m.Verify(signed)
if err != nil {
t.Fatalf("Verify: %v", err)
}
if id.TokenVersion != 3 {
t.Errorf("tv = %d, attendu 3", id.TokenVersion)
}
}
func TestVerifyLegacyTokenWithoutTv(t *testing.T) {
m, _ := NewManager("test-secret")
// Tokens pré-V3 (Issue, tv=0) : Verify lit 0 — valides tant que le
// compte n'a jamais bumpé (montée en version sans coupure).
signed, err := m.Issue(testUserID, testDeviceID)
if err != nil {
t.Fatalf("Issue: %v", err)
}
id, err := m.Verify(signed)
if err != nil {
t.Fatalf("Verify legacy: %v", err)
}
if id.TokenVersion != 0 {
t.Errorf("tv legacy = %d, attendu 0", id.TokenVersion)
}
} }
+58
View File
@@ -52,3 +52,61 @@ func (d *Devices) MarkUser(deviceID, userID string) error {
} }
return nil return nil
} }
// DeviceRow is one registered device of an account (A1 — voir / révoquer).
type DeviceRow struct {
DeviceID string
LastSeenAt *int64 // ms epoch, NULL si jamais vu depuis l'enregistrement
}
// ListByUser returns the devices whose last login was this account
// (devices.user_id informatif, jamais autorisant).
func (d *Devices) ListByUser(userID string) ([]DeviceRow, error) {
rows, err := d.DB.Query(
`SELECT device_id, (EXTRACT(EPOCH FROM last_seen_at) * 1000)::bigint
FROM devices WHERE user_id = $1 ORDER BY last_seen_at DESC NULLS LAST`,
userID,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := []DeviceRow{}
for rows.Next() {
var row DeviceRow
if err := rows.Scan(&row.DeviceID, &row.LastSeenAt); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
// Revoke deletes a device registration of this account (A1 — téléphone
// perdu). Avec EnforceDeviceExists, les tokens du device deviennent 401 et
// le login refuse le device (ré-enregistrement explicite requis).
// Ligne absente ou d'un autre compte → ErrNotFound (pas d'énumération).
// Les hints de présence (`storage_locations`) suivent.
func (d *Devices) Revoke(userID, deviceID string) error {
result, err := d.DB.Exec(
`DELETE FROM devices WHERE device_id = $1 AND user_id = $2`,
deviceID, userID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
if _, err := d.DB.Exec(
`DELETE FROM storage_locations WHERE device_id = $1 AND user_id = $2`,
deviceID, userID,
); err != nil {
return err
}
return nil
}
+186
View File
@@ -0,0 +1,186 @@
package repository
import (
"database/sql"
)
// FactParam is one generic fact to persist (V3 S2, migration 000019).
// ValueNum/ValueDate nil when the type carries no numeric/date value.
type FactParam struct {
Type string
ValueText string
ValueNum *float64
ValueDate *string // ISO YYYY-MM-DD
Confidence float64
}
// FactRow is one persisted fact (auto-extracted or user-corrected).
type FactRow struct {
ID string
Type string
ValueText string
ValueNum *float64
ValueDate *string
Confidence float64
Origin string
}
// UpsertAutoFacts replaces the origin='auto' facts of a resource with a fresh
// extraction. Rows with origin='user' (S3 corrections) are never touched.
// An empty params clears stale auto facts (e.g. OCR re-run yielding nothing).
func (r *Resources) UpsertAutoFacts(resourceID string, params []FactParam) error {
tx, err := r.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback() //nolint:errcheck — no-op after Commit.
if _, err := tx.Exec(
`DELETE FROM resource_facts WHERE resource_id = $1 AND origin = 'auto'`,
resourceID,
); err != nil {
return err
}
for _, p := range params {
id, err := NewIDErr()
if err != nil {
return err
}
if _, err := tx.Exec(
`INSERT INTO resource_facts
(id, resource_id, fact_type, value_text, value_num, value_date, confidence, origin)
VALUES ($1, $2, $3, NULLIF($4, ''), $5, NULLIF($6, '')::date, $7, 'auto')`,
id, resourceID, p.Type, p.ValueText, nullableFloat(p.ValueNum), derefStr(p.ValueDate), clamp01(p.Confidence),
); err != nil {
return err
}
}
return tx.Commit()
}
// ListFacts returns the facts of a resource, user-corrected first then auto
// (stable order by type). No visibility check — the caller enforces viewer+
// (GetFileVisible) like GetFileOcr.
func (r *Resources) ListFacts(resourceID string) ([]FactRow, error) {
rows, err := r.DB.Query(
`SELECT id, fact_type, COALESCE(value_text, ''), value_num,
COALESCE(value_date::text, ''), confidence, origin
FROM resource_facts WHERE resource_id = $1
ORDER BY CASE origin WHEN 'user' THEN 0 ELSE 1 END, fact_type, value_text`,
resourceID,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]FactRow, 0)
for rows.Next() {
var row FactRow
var num sql.NullFloat64
var dat string
if err := rows.Scan(&row.ID, &row.Type, &row.ValueText, &num, &dat, &row.Confidence, &row.Origin); err != nil {
return nil, err
}
if num.Valid {
v := num.Float64
row.ValueNum = &v
}
if dat != "" {
d := dat
row.ValueDate = &d
}
out = append(out, row)
}
return out, rows.Err()
}
// CorrectFacts fully replaces the origin='user' set of a resource (S3 :
// correction en un tap — le client envoie le jeu corrigé complet, pas un
// diff). Auto facts are never touched. Empty params clears user corrections
// (back to pure auto).
func (r *Resources) CorrectFacts(resourceID string, params []FactParam) error {
tx, err := r.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback() //nolint:errcheck — no-op after Commit.
if _, err := tx.Exec(
`DELETE FROM resource_facts WHERE resource_id = $1 AND origin = 'user'`,
resourceID,
); err != nil {
return err
}
for _, p := range params {
id, err := NewIDErr()
if err != nil {
return err
}
if _, err := tx.Exec(
`INSERT INTO resource_facts
(id, resource_id, fact_type, value_text, value_num, value_date, confidence, origin)
VALUES ($1, $2, $3, NULLIF($4, ''), $5, NULLIF($6, '')::date, $7, 'user')`,
id, resourceID, p.Type, p.ValueText, nullableFloat(p.ValueNum), derefStr(p.ValueDate), clamp01(p.Confidence),
); err != nil {
return err
}
}
return tx.Commit()
}
type factNeedingExtract struct {
UserID string
ResourceID string
Text string
}
// ListNeedingExtract returns up to limit files with non-empty ocr_text and no
// origin='auto' facts (boot backfill, S2). Live rows only.
func (r *Resources) ListNeedingExtract(limit int) ([]factNeedingExtract, error) {
rows, err := r.DB.Query(
`SELECT user_id, resource_id, ocr_text FROM resources
WHERE type = 'file' AND deleted_at IS NULL AND user_id IS NOT NULL
AND ocr_text IS NOT NULL AND ocr_text <> ''
AND NOT EXISTS (
SELECT 1 FROM resource_facts
WHERE resource_facts.resource_id = resources.resource_id
AND origin = 'auto')
ORDER BY updated_at ASC LIMIT $1`,
limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []factNeedingExtract
for rows.Next() {
var row factNeedingExtract
if err := rows.Scan(&row.UserID, &row.ResourceID, &row.Text); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
func nullableFloat(v *float64) any {
if v == nil {
return nil
}
return *v
}
func derefStr(v *string) string {
if v == nil {
return ""
}
return *v
}
func clamp01(v float64) float64 {
if v < 0 {
return 0
}
if v > 1 {
return 1
}
return v
}
+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
}
+355
View File
@@ -0,0 +1,355 @@
package repository
import (
"database/sql"
)
// Link types — mirror of the resource_links CHECK (migration 000021).
// All types are symmetric : stored once with from_id < to_id (canonical
// order), read from either end. version_of is intentionally absent :
// versions live INSIDE a resource (resource_versions, 000018).
const (
LinkSameScan = "same_scan"
LinkDuplicateOf = "duplicate_of"
LinkSameIssuer = "same_issuer"
LinkSameReference = "same_reference"
)
// LinkRow is one edge viewed from the queried resource.
type LinkRow struct {
ID string
OtherID string
Type string
Confidence float64
CreatedBy string
OtherName string
OtherType string
OtherSize int64
}
// canonicalPair orders an unordered pair for symmetric storage.
func canonicalPair(a, b string) (string, string) {
if a < b {
return a, b
}
return b, a
}
// ListLinks returns the live edges touching resourceID (either direction),
// joined with the other end's identity. Trashed others are excluded.
// No ownership check — the caller scopes (owner-only in S5).
func (r *Resources) ListLinks(resourceID string) ([]LinkRow, error) {
rows, err := r.DB.Query(
`SELECT l.id,
CASE WHEN l.from_id = $1 THEN l.to_id ELSE l.from_id END AS other_id,
l.link_type, l.confidence, l.created_by,
o.name, o.type, COALESCE(o.size_bytes, 0)
FROM resource_links l
JOIN resources o ON o.resource_id = CASE WHEN l.from_id = $1 THEN l.to_id ELSE l.from_id END
WHERE (l.from_id = $1 OR l.to_id = $1)
AND o.deleted_at IS NULL
ORDER BY l.confidence DESC, o.name ASC`,
resourceID,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]LinkRow, 0)
for rows.Next() {
var row LinkRow
if err := rows.Scan(&row.ID, &row.OtherID, &row.Type, &row.Confidence, &row.CreatedBy, &row.OtherName, &row.OtherType, &row.OtherSize); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
// ensureAutoLink inserts a symmetric auto edge (canonical order). Any
// existing row — auto or user verdict — blocks recreation (an invalidated
// edge never comes back by itself).
func (r *Resources) ensureAutoLink(from, to, linkType string, confidence float64) error {
a, b := canonicalPair(from, to)
id, err := NewIDErr()
if err != nil {
return err
}
_, err = r.DB.Exec(
`INSERT INTO resource_links (id, from_id, to_id, link_type, confidence, created_by)
VALUES ($1, $2, $3, $4, $5, 'auto')
ON CONFLICT (from_id, to_id, link_type) DO NOTHING`,
id, a, b, linkType, clamp01(confidence),
)
return err
}
// SetUserVerdict records an explicit verdict (created_by='user') : confirm →
// confidence 1.0, invalidate → 0.0. Upserts over any previous row (auto or
// older verdict) — the latest human word wins.
func (r *Resources) SetUserVerdict(one, other, linkType string, confirmed bool) error {
a, b := canonicalPair(one, other)
conf := 0.0
if confirmed {
conf = 1.0
}
id, err := NewIDErr()
if err != nil {
return err
}
_, err = r.DB.Exec(
`INSERT INTO resource_links (id, from_id, to_id, link_type, confidence, created_by)
VALUES ($1, $2, $3, $4, $5, 'user')
ON CONFLICT (from_id, to_id, link_type)
DO UPDATE SET confidence = EXCLUDED.confidence, created_by = 'user'`,
id, a, b, linkType, conf,
)
return err
}
// pruneAutoLinks drops auto edges of the symmetric types touching resourceID
// whose pair is no longer a candidate (facts/session edited). keep holds
// canonical "a\x00b\x00type" keys to preserve. User verdicts are never pruned.
func (r *Resources) pruneAutoLinks(resourceID string, keep map[string]bool) error {
rows, err := r.DB.Query(
`SELECT id, from_id, to_id, link_type FROM resource_links
WHERE (from_id = $1 OR to_id = $1) AND created_by = 'auto'`,
resourceID,
)
if err != nil {
return err
}
var stale []string
for rows.Next() {
var id, a, b, typ string
if err := rows.Scan(&id, &a, &b, &typ); err != nil {
rows.Close()
return err
}
if !keep[a+"\x00"+b+"\x00"+typ] {
stale = append(stale, id)
}
}
rows.Close()
if err := rows.Err(); err != nil {
return err
}
for _, id := range stale {
if _, err := r.DB.Exec(`DELETE FROM resource_links WHERE id = $1`, id); err != nil {
return err
}
}
return nil
}
// linkCandidate is one deterministic pair found by reconciliation.
type linkCandidate struct {
other string
typ string
confidence float64
}
// ReconcileLinks recomputes the deterministic auto edges of a live owned
// resource (same_scan, duplicate_of, same_issuer, same_reference), creates
// missing ones and prunes stale auto ones. User verdicts are preserved and
// block recreation. Idempotent — safe to call on every read (GET links).
func (r *Resources) ReconcileLinks(ownerID, resourceID string) error {
var session sql.NullString
var hash sql.NullString
var size int64
err := r.DB.QueryRow(
`SELECT COALESCE(scan_session_id, ''), COALESCE(content_hash, ''), COALESCE(size_bytes, 0)
FROM resources WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
resourceID, ownerID,
).Scan(&session, &hash, &size)
if err == sql.ErrNoRows {
return ErrNotFound
}
if err != nil {
return err
}
var cands []linkCandidate
// same_scan : same opaque session, same user, live, not self.
if session.Valid && session.String != "" {
rows, err := r.DB.Query(
`SELECT resource_id FROM resources
WHERE user_id = $1 AND scan_session_id = $2 AND resource_id != $3 AND deleted_at IS NULL`,
ownerID, session.String, resourceID,
)
if err != nil {
return err
}
for rows.Next() {
var other string
if err := rows.Scan(&other); err != nil {
rows.Close()
return err
}
cands = append(cands, linkCandidate{other, LinkSameScan, 1.0})
}
rows.Close()
if err := rows.Err(); err != nil {
return err
}
}
// duplicate_of : same content hash (non-empty), size > 0, same user, live.
if hash.Valid && hash.String != "" && size > 0 {
rows, err := r.DB.Query(
`SELECT resource_id FROM resources
WHERE user_id = $1 AND content_hash = $2 AND size_bytes > 0
AND resource_id != $3 AND deleted_at IS NULL`,
ownerID, hash.String, resourceID,
)
if err != nil {
return err
}
for rows.Next() {
var other string
if err := rows.Scan(&other); err != nil {
rows.Close()
return err
}
cands = append(cands, linkCandidate{other, LinkDuplicateOf, 1.0})
}
rows.Close()
if err := rows.Err(); err != nil {
return err
}
}
// same_issuer / same_reference : shared fact values (case-insensitive
// for issuers, exact for reference codes), any origin (user corrections
// count — they ARE the household truth). Effective facts only : un fait
// auto est ignoré quand un fait user du même type existe sur la même
// ressource (miroir de `displayFacts` côté mobile — sinon une correction
// laisserait l'arête auto périmée).
for _, typ := range []string{"issuer", "reference"} {
linkTyp := LinkSameIssuer
if typ == "reference" {
linkTyp = LinkSameReference
}
rows, err := r.DB.Query(
`SELECT DISTINCT o.resource_id, LEAST(f.confidence, g.confidence)
FROM resource_facts f
JOIN resource_facts g ON g.fact_type = f.fact_type
AND g.resource_id != f.resource_id
AND CASE WHEN f.fact_type = 'issuer'
THEN LOWER(g.value_text) = LOWER(f.value_text)
ELSE g.value_text = f.value_text END
JOIN resources o ON o.resource_id = g.resource_id
WHERE f.resource_id = $1 AND f.fact_type = $2 AND f.value_text IS NOT NULL
AND (f.origin = 'user' OR NOT EXISTS (
SELECT 1 FROM resource_facts u WHERE u.resource_id = f.resource_id
AND u.fact_type = f.fact_type AND u.origin = 'user'))
AND (g.origin = 'user' OR NOT EXISTS (
SELECT 1 FROM resource_facts u WHERE u.resource_id = g.resource_id
AND u.fact_type = g.fact_type AND u.origin = 'user'))
AND o.user_id = $3 AND o.deleted_at IS NULL`,
resourceID, typ, ownerID,
)
if err != nil {
return err
}
for rows.Next() {
var other string
var conf float64
if err := rows.Scan(&other, &conf); err != nil {
rows.Close()
return err
}
cands = append(cands, linkCandidate{other, linkTyp, conf})
}
rows.Close()
if err := rows.Err(); err != nil {
return err
}
}
keep := make(map[string]bool, len(cands))
for _, c := range cands {
a, b := canonicalPair(resourceID, c.other)
keep[a+"\x00"+b+"\x00"+c.typ] = true
if err := r.ensureAutoLink(resourceID, c.other, c.typ, c.confidence); err != nil {
return err
}
}
return r.pruneAutoLinks(resourceID, keep)
}
// DuplicateGroup is one set of byte-identical live files (B2 screen).
type DuplicateGroup struct {
ContentHash string
Count int
TotalBytes int64
ReclaimableBytes int64 // total - biggest member (garder un seul)
Files []DuplicateFile
}
// DuplicateFile is one member of a duplicate group, newest first.
type DuplicateFile struct {
ID string
Name string
Size int64
UpdatedAt int64 // ms epoch
}
// ListDuplicateGroups returns the owner's byte-identical file sets
// (content_hash non-empty, size > 0, live only), biggest groups first.
func (r *Resources) ListDuplicateGroups(ownerID string) ([]DuplicateGroup, error) {
rows, err := r.DB.Query(
`SELECT content_hash, COUNT(*), COALESCE(SUM(size_bytes), 0)
FROM resources
WHERE user_id = $1 AND type = 'file' AND deleted_at IS NULL
AND content_hash IS NOT NULL AND content_hash <> '' AND size_bytes > 0
GROUP BY content_hash HAVING COUNT(*) > 1
ORDER BY SUM(size_bytes) DESC`,
ownerID,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := []DuplicateGroup{}
for rows.Next() {
var g DuplicateGroup
if err := rows.Scan(&g.ContentHash, &g.Count, &g.TotalBytes); err != nil {
return nil, err
}
members, err := r.DB.Query(
`SELECT resource_id, name, COALESCE(size_bytes, 0),
(EXTRACT(EPOCH FROM updated_at) * 1000)::bigint
FROM resources
WHERE user_id = $1 AND type = 'file' AND deleted_at IS NULL AND content_hash = $2
ORDER BY updated_at DESC`,
ownerID, g.ContentHash,
)
if err != nil {
return nil, err
}
var biggest int64
for members.Next() {
var f DuplicateFile
if err := members.Scan(&f.ID, &f.Name, &f.Size, &f.UpdatedAt); err != nil {
members.Close()
return nil, err
}
if f.Size > biggest {
biggest = f.Size
}
g.Files = append(g.Files, f)
}
members.Close()
if err := members.Err(); err != nil {
return nil, err
}
g.ReclaimableBytes = g.TotalBytes - biggest
out = append(out, g)
}
if err := rows.Err(); err != nil {
return nil, err
}
return out, nil
}
+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()
}
+39
View File
@@ -0,0 +1,39 @@
package repository
import (
"database/sql"
"time"
)
// PreviewRow mémorise la vignette servie (V3 S7, migration 000024).
type PreviewRow struct {
SrcSize int64
SrcUpdatedAt time.Time
}
// GetPreview lit la génération servie. Absente → sql.ErrNoRows (régénérer).
func (r *Resources) GetPreview(resourceID string) (PreviewRow, error) {
var row PreviewRow
err := r.DB.QueryRow(
`SELECT src_size_bytes, src_updated_at FROM resource_previews WHERE resource_id = $1`,
resourceID,
).Scan(&row.SrcSize, &row.SrcUpdatedAt)
if err == sql.ErrNoRows {
return PreviewRow{}, err
}
return row, err
}
// UpsertPreview mémorise la génération servie (taille + updated_at sources).
func (r *Resources) UpsertPreview(resourceID string, srcSize int64, srcUpdatedAt time.Time) error {
_, err := r.DB.Exec(
`INSERT INTO resource_previews (resource_id, src_size_bytes, src_updated_at)
VALUES ($1, $2, $3)
ON CONFLICT (resource_id)
DO UPDATE SET src_size_bytes = EXCLUDED.src_size_bytes,
src_updated_at = EXCLUDED.src_updated_at,
created_at = NOW()`,
resourceID, srcSize, srcUpdatedAt,
)
return err
}
+4
View File
@@ -12,6 +12,8 @@ type Repository struct {
OcrJobs *OcrJobs OcrJobs *OcrJobs
Users *Users Users *Users
Shares *Shares Shares *Shares
Placements *Placements
Groups *Groups
} }
func NewRepository(conn *sql.DB) *Repository { func NewRepository(conn *sql.DB) *Repository {
@@ -22,5 +24,7 @@ func NewRepository(conn *sql.DB) *Repository {
OcrJobs: &OcrJobs{DB: conn}, OcrJobs: &OcrJobs{DB: conn},
Users: &Users{DB: conn}, Users: &Users{DB: conn},
Shares: &Shares{DB: conn}, Shares: &Shares{DB: conn},
Placements: &Placements{DB: conn},
Groups: &Groups{DB: conn},
} }
} }
+231 -18
View File
@@ -51,15 +51,122 @@ func isForeignKeyViolation(err error) bool {
return errors.As(err, &pqErr) && pqErr.Code == "23503" return errors.As(err, &pqErr) && pqErr.Code == "23503"
} }
// SetContentHash stores the SHA-256 of the live bytes (V3 S5 duplicates).
// Owner-scoped, live rows. Best-effort côté service (jamais d'erreur vers
// le client).
func (r *Resources) SetContentHash(ownerID, resourceID, hash string) error {
result, err := r.DB.Exec(
`UPDATE resources SET content_hash = NULLIF($3, ''), updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND type = 'file' AND deleted_at IS NULL`,
resourceID, ownerID, hash,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// SetScanSession records the opaque client scan-session of a resource
// (V3 S5 same_scan — drift informatif, jamais autorisant). Owner-scoped.
func (r *Resources) SetScanSession(ownerID, resourceID, sessionID string) error {
result, err := r.DB.Exec(
`UPDATE resources SET scan_session_id = NULLIF($3, ''), updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
resourceID, ownerID, sessionID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// MissingHash identifies a live file without content_hash (boot backfill).
type MissingHash struct {
UserID string
ResourceID string
}
// ListMissingHashes returns up to limit live files with bytes but no hash.
func (r *Resources) ListMissingHashes(limit int) ([]MissingHash, error) {
rows, err := r.DB.Query(
`SELECT user_id, resource_id FROM resources
WHERE type = 'file' AND deleted_at IS NULL AND user_id IS NOT NULL AND has_content = TRUE
AND (content_hash IS NULL OR content_hash = '')
ORDER BY updated_at ASC LIMIT $1`,
limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []MissingHash
for rows.Next() {
var m MissingHash
if err := rows.Scan(&m.UserID, &m.ResourceID); err != nil {
return nil, err
}
out = append(out, m)
}
return out, rows.Err()
}
// StorageUsage aggregates a user's footprint (V3 S6 A2 — calculé, jamais
// stocké). Les trashés sont exclus (octets récupérables à la purge).
type StorageUsage struct {
UsedBytes int64
FileCount int
TrashCount int
TrashedBytes int64
}
// StorageUsage sums live file bytes + counts (live + trashed) for a user.
func (r *Resources) StorageUsage(ownerID string) (StorageUsage, error) {
var u StorageUsage
err := r.DB.QueryRow(
`SELECT COALESCE(SUM(size_bytes), 0), COUNT(*)
FROM resources
WHERE user_id = $1 AND type = 'file' AND deleted_at IS NULL`,
ownerID,
).Scan(&u.UsedBytes, &u.FileCount)
if err != nil {
return StorageUsage{}, err
}
err = r.DB.QueryRow(
`SELECT COUNT(*), COALESCE(SUM(size_bytes), 0)
FROM resources
WHERE user_id = $1 AND deleted_at IS NOT NULL`,
ownerID,
).Scan(&u.TrashCount, &u.TrashedBytes)
if err != nil {
return StorageUsage{}, err
}
return u, nil
}
type FileRow struct { type FileRow struct {
ID string ID string
Name string Name string
Size int64 Size int64
MimeType string MimeType string
FolderID string FolderID string
CreatedAt time.Time CreatedAt time.Time
UpdatedAt time.Time UpdatedAt time.Time
OcrText string OcrText string
HasContent bool
} }
type FolderRow struct { type FolderRow struct {
@@ -112,7 +219,7 @@ const grantedCTE = `
sh.inherit, 0 sh.inherit, 0
FROM shares sh FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id 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 (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL AND r.deleted_at IS NULL
), ),
@@ -172,11 +279,11 @@ func (r *Resources) InsertFolder(ownerID, id, name, parentResourceID string) err
return r.insert(ownerID, id, name, parentResourceID, "folder", 0, nil, nil) return r.insert(ownerID, id, name, parentResourceID, "folder", 0, nil, nil)
} }
const fileColumns = `resource_id, name, size_bytes, COALESCE(mime_type, ''), COALESCE(parent_id, ''), created_at, updated_at, 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) { func (r *Resources) scanFile(scan func(...any) error) (FileRow, error) {
var row FileRow var row FileRow
err := scan(&row.ID, &row.Name, &row.Size, &row.MimeType, &row.FolderID, &row.CreatedAt, &row.UpdatedAt, &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 return row, err
} }
@@ -500,9 +607,10 @@ func (r *Resources) UpdateNameByID(resourceID, name string) error {
// (size_bytes / mime_type / extension) after a targeted re-upload — used so a // (size_bytes / mime_type / extension) after a targeted re-upload — used so a
// resource created metadata-only (outbox create_resource) receives its bytes // resource created metadata-only (outbox create_resource) receives its bytes
// for server-side OCR. Absent / not owned → ErrNotFound. Never renames or moves. // 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 { func (r *Resources) UpdatePhysical(ownerID, resourceID string, size int64, mimeType, extension *string) error {
result, err := r.DB.Exec( 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`, WHERE resource_id = $1 AND user_id = $2 AND type = 'file' AND deleted_at IS NULL`,
resourceID, ownerID, size, mimeType, extension, resourceID, ownerID, size, mimeType, extension,
) )
@@ -519,6 +627,29 @@ func (r *Resources) UpdatePhysical(ownerID, resourceID string, size int64, mimeT
return nil 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 // UpdateOcrText writes the server-computed OCR extract onto the resource
// (owner-scoped, bumping updated_at so the change flows through the sync // (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 // snapshot). The text is then readable by every device of the user AND by
@@ -544,13 +675,12 @@ func (r *Resources) UpdateOcrText(ownerID, resourceID, text string) error {
// SyncDelete soft-deletes a resource; absence is NOT an error (idempotent // SyncDelete soft-deletes a resource; absence is NOT an error (idempotent
// terminal state for the outbox). // terminal state for the outbox).
//
// Deprecated: V3 trash — préférer TrashResource (récursif sur le subtree).
// Conservé comme alias pour compatibilité (même effet sur une ressource
// sans enfant : TrashResource ne touche que deleted_at IS NULL).
func (r *Resources) SyncDelete(ownerID, resourceID string) error { func (r *Resources) SyncDelete(ownerID, resourceID string) error {
_, err := r.DB.Exec( return r.TrashResource(ownerID, resourceID)
`UPDATE resources SET deleted_at = NOW(), updated_at = NOW()
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
resourceID, ownerID,
)
return err
} }
// ExistsOwner reports whether a non-deleted resource belongs to the device. // ExistsOwner reports whether a non-deleted resource belongs to the device.
@@ -603,6 +733,24 @@ func (r *Resources) TouchResource(resourceID string) error {
return err return err
} }
// LiveNameAndUpdatedAt returns the current name and updated_at (ms epoch) of
// a live resource, any type, unscoped — the caller (sync) has already
// verified effective access. Absent/trashed → ErrNotFound. Sert à la
// détection de conflits de rename (S6 A4 : baseUpdatedAt périmé).
func (r *Resources) LiveNameAndUpdatedAt(resourceID string) (string, int64, error) {
var name string
var ms int64
err := r.DB.QueryRow(
`SELECT name, (EXTRACT(EPOCH FROM updated_at) * 1000)::bigint
FROM resources WHERE resource_id = $1 AND deleted_at IS NULL`,
resourceID,
).Scan(&name, &ms)
if err == sql.ErrNoRows {
return "", 0, ErrNotFound
}
return name, ms, err
}
// OwnedRow is a snapshot row: resource identity + freshness. // OwnedRow is a snapshot row: resource identity + freshness.
type OwnedRow struct { type OwnedRow struct {
ID string ID string
@@ -683,3 +831,68 @@ func (r *Resources) ListRootFoldersVisible(userID string) ([]FolderRow, error) {
} }
return folders, rows.Err() return folders, rows.Err()
} }
// ExportFileRow is one live file for full export (V3 S7 C3).
type ExportFileRow struct {
ID string
Name string
ParentID string
Size int64
MimeType string
Extension string
Hash string
OcrText string
HasContent bool
}
// ExportFiles returns ALL live files of a user (bounded — full export).
func (r *Resources) ExportFiles(ownerID string, limit int) ([]ExportFileRow, error) {
rows, err := r.DB.Query(
`SELECT resource_id, name, COALESCE(parent_id, ''), COALESCE(size_bytes, 0),
COALESCE(mime_type, ''), COALESCE(extension, ''),
COALESCE(content_hash, ''), COALESCE(ocr_text, ''),
COALESCE(has_content, FALSE)
FROM resources
WHERE user_id = $1 AND type = 'file' AND deleted_at IS NULL
ORDER BY created_at ASC LIMIT $2`,
ownerID, limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]ExportFileRow, 0)
for rows.Next() {
var row ExportFileRow
if err := rows.Scan(&row.ID, &row.Name, &row.ParentID, &row.Size, &row.MimeType,
&row.Extension, &row.Hash, &row.OcrText, &row.HasContent); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
// ExportFolders returns ALL live folders of a user (bounded — full export).
func (r *Resources) ExportFolders(ownerID string, limit int) ([]FolderRow, error) {
rows, err := r.DB.Query(
`SELECT resource_id, name, COALESCE(parent_id, '')
FROM resources
WHERE user_id = $1 AND type = 'folder' AND deleted_at IS NULL
ORDER BY created_at ASC LIMIT $2`,
ownerID, limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]FolderRow, 0)
for rows.Next() {
var folder FolderRow
if err := rows.Scan(&folder.ID, &folder.Name, &folder.ParentID); err != nil {
return nil, err
}
out = append(out, folder)
}
return out, rows.Err()
}
+169
View File
@@ -0,0 +1,169 @@
package repository
import (
"fmt"
"strings"
)
// SearchFacets filters document search on extracted facts (V3 S4).
// Empty = no filter. From/To are ISO dates (YYYY-MM-DD) applied to
// date/due_date facts and overlapped with period facts (YYYY-MM).
type SearchFacets struct {
Issuer string
From, To string
MinAmount, MaxAmount *float64
DocType string
}
// searchFileColumns mirrors fileColumns qualified for `resources r`.
const searchFileColumns = `r.resource_id, r.name, r.size_bytes, COALESCE(r.mime_type, ''), COALESCE(r.parent_id, ''), r.created_at, r.updated_at, COALESCE(r.ocr_text, ''), COALESCE(r.has_content, FALSE)`
// SearchDocumentsVisible returns the user's accessible files (owned or
// shared, viewer+) matching q across name (ILIKE, compat), full-text
// (french TS, name+OCR) and extracted facts (ILIKE on value_text),
// optionally narrowed by facets. Ranked: TS rank + fact bonus (high-
// confidence fact match +1.0, low-confidence +0.5 — humble by design :
// low-confidence demotes, never excludes), then name.
func (r *Resources) SearchDocumentsVisible(userID, q string, facets SearchFacets, limit, offset int) ([]FileRow, int, error) {
where, order, args := r.searchDocumentsClauses(userID, q, facets)
base := `WITH RECURSIVE ` + grantedCTE + ` SELECT %s FROM resources r WHERE ` + where
var total int
if err := r.DB.QueryRow(fmt.Sprintf(base, "COUNT(*)"), args...).Scan(&total); err != nil {
return nil, 0, err
}
rows, err := r.DB.Query(
fmt.Sprintf(base+` ORDER BY %s, r.name ASC LIMIT $%d OFFSET $%d`, searchFileColumns, order, len(args)+1, len(args)+2),
append(args, limit, offset)...,
)
if err != nil {
return nil, 0, err
}
defer rows.Close()
files := make([]FileRow, 0)
for rows.Next() {
row, err := r.scanFile(rows.Scan)
if err != nil {
return nil, 0, err
}
files = append(files, row)
}
return files, total, rows.Err()
}
// searchDocumentsClauses builds the WHERE (match) and ORDER BY (rank)
// fragments plus bound args. $1 is always userID (grantedCTE).
func (r *Resources) searchDocumentsClauses(userID, q string, facets SearchFacets) (where, order string, args []any) {
args = []any{userID}
next := 2
ph := func(v any) string {
args = append(args, v)
p := fmt.Sprintf("$%d", next)
next++
return p
}
// plainto_tsquery placeholder partagé match/rang (le COUNT ne voit que
// le WHERE : aucun placeholder ne doit n'exister que dans le ORDER BY).
// Même règle pour le pattern LIKE du nom (bonus de rang).
tsPh := ph(q)
namePh := ph(`%` + escapeLike(q) + `%`)
matchAlts := []string{
`r.name ILIKE ` + namePh + ` ESCAPE '\'`,
`r.search_tsv @@ plainto_tsquery('french', ` + tsPh + `)`,
}
// Fact word matches (words >= 3 chars — shorter are French stopwords).
// `pat` est partagé entre le match et le bonus du rang : le COUNT ne voit
// que le WHERE, aucun placeholder ne doit n'exister que dans le ORDER BY.
words := longWords(q, 3, 5)
var wordConds, wordCondsHigh []string
for _, w := range words {
pat := ph(`%` + escapeLike(w) + `%`)
wordConds = append(wordConds,
`EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.value_text ILIKE `+pat+` ESCAPE '\')`)
wordCondsHigh = append(wordCondsHigh,
`EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.confidence >= 0.5 AND f.value_text ILIKE `+pat+` ESCAPE '\')`)
}
if len(wordConds) > 0 {
matchAlts = append(matchAlts, `(`+strings.Join(wordConds, " OR ")+`)`)
}
rankParts := []string{
// Match nom exact : bonus dominant (2.0) — un nom trouvé bat
// toujours un fait douteux (0.5), humble par design.
`CASE WHEN r.name ILIKE ` + namePh + ` ESCAPE '\' THEN 2.0 ELSE 0 END`,
`COALESCE(ts_rank_cd(r.search_tsv, plainto_tsquery('french', ` + tsPh + `)), 0)`,
}
if len(wordCondsHigh) > 0 {
rankParts = append(rankParts,
`CASE WHEN (`+strings.Join(wordCondsHigh, " OR ")+`) THEN 1.0 WHEN (`+strings.Join(wordConds, " OR ")+`) THEN 0.5 ELSE 0 END`)
}
conds := []string{
`r.type = 'file'`,
`r.deleted_at IS NULL`,
`r.resource_id IN (SELECT id FROM granted)`,
`(` + strings.Join(matchAlts, " OR ") + `)`,
}
// Facets (AND).
if facets.Issuer != "" {
conds = append(conds,
`EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.fact_type = 'issuer' AND f.value_text ILIKE `+ph(`%`+escapeLike(facets.Issuer)+`%`)+` ESCAPE '\')`)
}
if facets.DocType != "" {
conds = append(conds,
`EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.fact_type = 'doc_type' AND f.value_text = `+ph(facets.DocType)+`)`)
}
if facets.MinAmount != nil {
conds = append(conds,
`EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.fact_type = 'amount' AND f.value_num >= `+ph(*facets.MinAmount)+`)`)
}
if facets.MaxAmount != nil {
conds = append(conds,
`EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.fact_type = 'amount' AND f.value_num <= `+ph(*facets.MaxAmount)+`)`)
}
if facets.From != "" || facets.To != "" {
from := facets.From
if from == "" {
from = "0001-01-01"
}
to := facets.To
if to == "" {
to = "9999-12-31"
}
fromMonth, toMonth := from, to
if len(fromMonth) >= 7 {
fromMonth = fromMonth[:7]
}
if len(toMonth) >= 7 {
toMonth = toMonth[:7]
}
conds = append(conds, `(
EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.fact_type IN ('date', 'due_date') AND f.value_date >= `+ph(from)+`::date AND f.value_date <= `+ph(to)+`::date)
OR EXISTS (SELECT 1 FROM resource_facts f WHERE f.resource_id = r.resource_id AND f.fact_type = 'period' AND f.value_text >= `+ph(fromMonth)+` AND f.value_text <= `+ph(toMonth)+`)
)`)
}
where = strings.Join(conds, " AND ")
order = strings.Join(rankParts, " + ") + " DESC"
return where, order, args
}
// longWords splits q into words of at least minLen runes, capped at max.
func longWords(q string, minLen, max int) []string {
var out []string
seen := map[string]bool{}
for _, w := range strings.Fields(q) {
if len([]rune(w)) < minLen || seen[w] {
continue
}
seen[w] = true
out = append(out, w)
if len(out) >= max {
break
}
}
return out
}
+165
View File
@@ -0,0 +1,165 @@
package repository
import (
"testing"
"github.com/kazier/backend/dbtest"
)
const searchTestURL = "postgres://kazier:kazier@localhost:5432/kazier_search_test?sslmode=disable"
func newSearchRepo(t *testing.T) *Repository {
t.Helper()
return NewRepository(dbtest.OpenTestDatabase(t, searchTestURL))
}
func mustSearchUser(t *testing.T, repo *Repository, username string) string {
t.Helper()
id, err := repo.Users.Create(username, username, "test-hash", false)
if err != nil {
t.Fatalf("create user: %v", err)
}
return id
}
func seedDoc(t *testing.T, repo *Repository, userID, name, ocr string, facts []FactParam) string {
t.Helper()
id := NewID()
if err := repo.Resources.InsertFile(userID, id, name, "", 0, nil, nil); err != nil {
t.Fatalf("insert %q: %v", name, err)
}
if ocr != "" {
if err := repo.Resources.UpdateOcrText(userID, id, ocr); err != nil {
t.Fatalf("ocr %q: %v", name, err)
}
}
if len(facts) > 0 {
if err := repo.Resources.UpsertAutoFacts(id, facts); err != nil {
t.Fatalf("facts %q: %v", name, err)
}
}
return id
}
func f64(v float64) *float64 { return &v }
func fstr(v string) *string { return &v }
func searchIDs(t *testing.T, repo *Repository, userID, q string, facets SearchFacets) []string {
t.Helper()
rows, _, err := repo.Resources.SearchDocumentsVisible(userID, q, facets, 50, 0)
if err != nil {
t.Fatalf("search %q: %v", q, err)
}
ids := make([]string, 0, len(rows))
for _, r := range rows {
ids = append(ids, r.ID)
}
return ids
}
func containsID(ids []string, want string) bool {
for _, id := range ids {
if id == want {
return true
}
}
return false
}
func TestSearchDocumentsFTS(t *testing.T) {
repo := newSearchRepo(t)
userID := mustSearchUser(t, repo, "search-fts")
// Nom opaque : trouvable uniquement via l'OCR (TS français).
scan := seedDoc(t, repo, userID, "scan_042.pdf",
"Attestation d'assurance MMA pour l'année 2026", nil)
plain := seedDoc(t, repo, userID, "assurance-vie.txt", "", nil)
ids := searchIDs(t, repo, userID, "assurance", SearchFacets{})
if !containsID(ids, scan) {
t.Errorf("scan_042.pdf introuvable via OCR: %v", ids)
}
if !containsID(ids, plain) {
t.Errorf("assurance-vie.txt introuvable via nom: %v", ids)
}
// Stemming français : "factures" matche "facture".
fact := seedDoc(t, repo, userID, "doc.pdf", "Votre facture de mars", nil)
ids = searchIDs(t, repo, userID, "factures", SearchFacets{})
if !containsID(ids, fact) {
t.Errorf("stemming FR manquant: %v", ids)
}
}
func TestSearchDocumentsFacets(t *testing.T) {
repo := newSearchRepo(t)
userID := mustSearchUser(t, repo, "search-facets")
edf := seedDoc(t, repo, userID, "edf.pdf", "Facture EDF", []FactParam{
{Type: "issuer", ValueText: "EDF", Confidence: 0.9},
{Type: "amount", ValueText: "84.20 €", ValueNum: f64(84.20), Confidence: 0.9},
{Type: "due_date", ValueText: "2026-04-12", ValueDate: fstr("2026-04-12"), Confidence: 0.8},
{Type: "doc_type", ValueText: "facture", Confidence: 0.8},
})
engie := seedDoc(t, repo, userID, "engie.pdf", "Facture Engie", []FactParam{
{Type: "issuer", ValueText: "ENGIE", Confidence: 0.9},
{Type: "amount", ValueText: "120.00 €", ValueNum: f64(120), Confidence: 0.9},
{Type: "doc_type", ValueText: "facture", Confidence: 0.8},
})
ids := searchIDs(t, repo, userID, "facture", SearchFacets{Issuer: "edf"})
if !containsID(ids, edf) || containsID(ids, engie) {
t.Errorf("facette issuer: %v", ids)
}
ids = searchIDs(t, repo, userID, "facture", SearchFacets{MinAmount: f64(100)})
if !containsID(ids, engie) || containsID(ids, edf) {
t.Errorf("facette min_amount: %v", ids)
}
ids = searchIDs(t, repo, userID, "facture", SearchFacets{DocType: "facture"})
if !containsID(ids, edf) || !containsID(ids, engie) {
t.Errorf("facette doc_type: %v", ids)
}
ids = searchIDs(t, repo, userID, "facture", SearchFacets{From: "2026-04-01", To: "2026-04-30"})
if !containsID(ids, edf) || containsID(ids, engie) {
t.Errorf("facette période: %v", ids)
}
}
func TestSearchDocumentsLowConfidenceDemotes(t *testing.T) {
repo := newSearchRepo(t)
userID := mustSearchUser(t, repo, "search-humble")
// Fait douteux (0.3) : trouvé quand même (jamais exclu), mais après le
// match franc (nom) — humble par design.
sure := seedDoc(t, repo, userID, "EDF-contrat.pdf", "", nil)
doubt := seedDoc(t, repo, userID, "scan_x.pdf", "courrier", []FactParam{
{Type: "issuer", ValueText: "EDF", Confidence: 0.3},
})
ids := searchIDs(t, repo, userID, "EDF", SearchFacets{})
if !containsID(ids, doubt) {
t.Fatalf("fait douteux exclu (interdit): %v", ids)
}
if len(ids) < 2 || ids[0] != sure || ids[1] != doubt {
t.Errorf("ordre de rang inattendu (franc avant douteux): %v", ids)
}
}
func TestSearchDocumentsTrashedExcluded(t *testing.T) {
repo := newSearchRepo(t)
userID := mustSearchUser(t, repo, "search-trash")
id := seedDoc(t, repo, userID, "poubelle.pdf", "contenu unique xyz", nil)
if ids := searchIDs(t, repo, userID, "xyz", SearchFacets{}); !containsID(ids, id) {
t.Fatalf("introuvable avant trash: %v", ids)
}
if err := repo.Resources.TrashResource(userID, id); err != nil {
t.Fatalf("trash: %v", err)
}
if ids := searchIDs(t, repo, userID, "xyz", SearchFacets{}); containsID(ids, id) {
t.Errorf("trashé encore visible: %v", ids)
}
}
+102 -9
View File
@@ -71,11 +71,19 @@ type ResourceAccess struct {
Inherit bool 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 { type Shares struct {
DB *sql.DB 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 // Upsert inserts or updates an active share. On conflict (active row for
// same resource + grantee) the access, inherit, and expires_at are updated. // 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 { 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 return err
} }
// Revoke soft-revokes the active share between a resource and a grantee. // Revoke soft-revokes the active share between a resource and a grantee
func (s *Shares) Revoke(resourceID, granteeUserID string) error { // (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( result, err := s.DB.Exec(
`UPDATE shares SET revoked_at = NOW(), updated_at = NOW() `UPDATE shares SET revoked_at = NOW(), updated_at = NOW()
WHERE resource_id = $1 AND grantee_user_id = $2 AND revoked_at IS NULL`, WHERE resource_id = $1 AND (grantee_user_id = $2 OR grantee_group_id = $2) AND revoked_at IS NULL`,
resourceID, granteeUserID, resourceID, granteeID,
) )
if err != nil { if err != nil {
return err 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 sh.created_by, sh.expires_at, sh.inherit, r.name, TRUE
FROM shares sh FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id 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 (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL 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 SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END AS rank
FROM shares sh FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id 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.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW()) AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL AND r.deleted_at IS NULL
@@ -276,7 +285,7 @@ inherited(id, grant_rank, depth) AS (
SELECT r.parent_id, SELECT r.parent_id,
COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END
FROM shares sh 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.revoked_at IS NULL AND sh.inherit
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0), AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0),
0 0
@@ -286,7 +295,7 @@ inherited(id, grant_rank, depth) AS (
SELECT r.parent_id, SELECT r.parent_id,
COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END
FROM shares sh 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.revoked_at IS NULL AND sh.inherit
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0), AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0),
ag.depth + 1 ag.depth + 1
@@ -455,5 +464,89 @@ func (s *Shares) ListActiveLinksForResource(resourceID string) ([]LinkInfo, erro
return links, rows.Err() 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. // Errors specific to shares.
var ErrGranteeNotFound = errors.New("grantee user not found") var ErrGranteeNotFound = errors.New("grantee user not found")
+191
View File
@@ -0,0 +1,191 @@
package repository
import (
"database/sql"
"time"
)
// TrashedRow is a trashed resource for GET /trash.
type TrashedRow struct {
ID string
Type string
Name string
Size int64
TrashedAt time.Time
UpdatedAt time.Time
}
// subtreeCTE selects a resource and all its descendants (any depth).
const subtreeCTE = `
subtree(id) AS (
SELECT $2::text
UNION ALL
SELECT r.resource_id FROM resources r JOIN subtree s ON r.parent_id = s.id
)`
// ancestorsCTE selects a resource and all its ancestors up to the root.
const ancestorsCTE = `
ancestors(id) AS (
SELECT $2::text
UNION ALL
SELECT r.parent_id FROM resources r JOIN ancestors a ON r.resource_id = a.id
WHERE r.parent_id IS NOT NULL
)`
// TrashResource soft-deletes a resource and its whole subtree
// (`deleted_at = NOW()`), owner-scoped. Already-trashed rows are untouched.
// The target must be verified owned beforehand (ExistsOwner / GetResourceOwner)
// for the NOT_FOUND halt semantics — this method only applies.
func (r *Resources) TrashResource(ownerID, resourceID string) error {
_, err := r.DB.Exec(
`WITH RECURSIVE `+subtreeCTE+`
UPDATE resources SET deleted_at = NOW(), updated_at = NOW()
WHERE resource_id IN (SELECT id FROM subtree)
AND user_id = $1 AND deleted_at IS NULL`,
ownerID, resourceID,
)
return err
}
// RestoreResource clears the trash flag on a resource, its subtree AND its
// ancestor chain (a file whose folder is still trashed would stay
// unreachable otherwise). Independently-trashed descendants are restored too
// — documented V3 behaviour (restoring the folder restores what it contains).
func (r *Resources) RestoreResource(ownerID, resourceID string) error {
_, err := r.DB.Exec(
`WITH RECURSIVE `+subtreeCTE+`, `+ancestorsCTE+`
UPDATE resources SET deleted_at = NULL, updated_at = NOW()
WHERE (resource_id IN (SELECT id FROM subtree)
OR resource_id IN (SELECT id FROM ancestors))
AND user_id = $1 AND deleted_at IS NOT NULL`,
ownerID, resourceID,
)
return err
}
// ExistsOwnerAny reports ownership regardless of trash state (for purge :
// a trashed resource is still owned).
func (r *Resources) ExistsOwnerAny(ownerID, resourceID string) (bool, error) {
var exists int
err := r.DB.QueryRow(
`SELECT 1 FROM resources WHERE resource_id = $1 AND user_id = $2`,
resourceID, ownerID,
).Scan(&exists)
if err == sql.ErrNoRows {
return false, nil
}
return err == nil, err
}
// PurgeResource hard-deletes a resource and its subtree (FK CASCADE on
// parent_id + resource_versions), returning every purged resource_id so the
// caller can remove physical files best-effort. Owner-scoped.
func (r *Resources) PurgeResource(ownerID, resourceID string) ([]string, error) {
rows, err := r.DB.Query(
`WITH RECURSIVE subtree(id) AS (
SELECT $1::text
UNION ALL
SELECT r.resource_id FROM resources r JOIN subtree s ON r.parent_id = s.id
)
SELECT id FROM subtree`,
resourceID,
)
if err != nil {
return nil, err
}
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return nil, err
}
ids = append(ids, id)
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, err
}
if _, err := r.DB.Exec(
`DELETE FROM resources WHERE resource_id = $1 AND user_id = $2`,
resourceID, ownerID,
); err != nil {
return nil, err
}
return ids, nil
}
// ListTrashed returns the owner's trashed resources, most recently trashed
// first, paginated.
func (r *Resources) ListTrashed(ownerID string, limit, offset int) ([]TrashedRow, int, error) {
var total int
if err := r.DB.QueryRow(
`SELECT COUNT(*) FROM resources WHERE user_id = $1 AND deleted_at IS NOT NULL`,
ownerID,
).Scan(&total); err != nil {
return nil, 0, err
}
rows, err := r.DB.Query(
`SELECT resource_id, type, name, COALESCE(size_bytes, 0), deleted_at, updated_at
FROM resources WHERE user_id = $1 AND deleted_at IS NOT NULL
ORDER BY deleted_at DESC LIMIT $2 OFFSET $3`,
ownerID, limit, offset,
)
if err != nil {
return nil, 0, err
}
defer rows.Close()
out := make([]TrashedRow, 0)
for rows.Next() {
var row TrashedRow
if err := rows.Scan(&row.ID, &row.Type, &row.Name, &row.Size, &row.TrashedAt, &row.UpdatedAt); err != nil {
return nil, 0, err
}
out = append(out, row)
}
return out, total, rows.Err()
}
// PurgedResource identifies a row destroyed by the retention pass.
type PurgedResource struct {
UserID string
ResourceID string
}
// PurgeExpiredTrash hard-deletes every resource trashed before cutoff
// (corbeille 30j), oldest first, bounded by limit. Returns the destroyed
// identities for physical-file cleanup (best-effort, caller-side).
func (r *Resources) PurgeExpiredTrash(cutoff time.Time, limit int) ([]PurgedResource, error) {
rows, err := r.DB.Query(
`SELECT user_id, resource_id FROM resources
WHERE deleted_at IS NOT NULL AND deleted_at < $1
ORDER BY deleted_at ASC LIMIT $2`,
cutoff, limit,
)
if err != nil {
return nil, err
}
var out []PurgedResource
for rows.Next() {
var p PurgedResource
if err := rows.Scan(&p.UserID, &p.ResourceID); err != nil {
rows.Close()
return nil, err
}
out = append(out, p)
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, err
}
for _, p := range out {
// Hard delete cascades to children (parent_id FK) and versions.
if _, err := r.DB.Exec(
`DELETE FROM resources WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NOT NULL AND deleted_at < $3`,
p.ResourceID, p.UserID, cutoff,
); err != nil {
return out, err
}
}
return out, nil
}
+30 -3
View File
@@ -13,6 +13,10 @@ type UserRow struct {
PasswordHash string PasswordHash string
IsAdmin bool IsAdmin bool
CreatedAt time.Time CreatedAt time.Time
// V3 S6 : révocation des tokens (bump au changement de password) et
// quota de stockage (garde-fou upload).
TokenVersion int
QuotaBytes int64
} }
// Users persiste les comptes utilisateurs (auth par login, cf. tranche identité). // Users persiste les comptes utilisateurs (auth par login, cf. tranche identité).
@@ -33,7 +37,8 @@ func (u *Users) Count() (int, error) {
// (lowercase, unique). Absent → ErrNotFound. // (lowercase, unique). Absent → ErrNotFound.
func (u *Users) GetByUsernameNormalized(normalized string) (*UserRow, error) { func (u *Users) GetByUsernameNormalized(normalized string) (*UserRow, error) {
row := u.DB.QueryRow( row := u.DB.QueryRow(
`SELECT id, username, username_normalized, password_hash, is_admin, created_at `SELECT id, username, username_normalized, password_hash, is_admin, created_at,
token_version, storage_quota_bytes
FROM users FROM users
WHERE username_normalized = $1 AND deleted_at IS NULL`, WHERE username_normalized = $1 AND deleted_at IS NULL`,
normalized, normalized,
@@ -48,7 +53,8 @@ func (u *Users) GetByUsernameNormalized(normalized string) (*UserRow, error) {
// GetByID charge un compte actif par id. Absent → ErrNotFound. // GetByID charge un compte actif par id. Absent → ErrNotFound.
func (u *Users) GetByID(id string) (*UserRow, error) { func (u *Users) GetByID(id string) (*UserRow, error) {
row := u.DB.QueryRow( row := u.DB.QueryRow(
`SELECT id, username, username_normalized, password_hash, is_admin, created_at `SELECT id, username, username_normalized, password_hash, is_admin, created_at,
token_version, storage_quota_bytes
FROM users FROM users
WHERE id = $1 AND deleted_at IS NULL`, WHERE id = $1 AND deleted_at IS NULL`,
id, id,
@@ -131,6 +137,27 @@ func (u *Users) MarkDeleted(id string) error {
func scanUser(scan func(...any) error) (*UserRow, error) { func scanUser(scan func(...any) error) (*UserRow, error) {
var user UserRow var user UserRow
err := scan(&user.ID, &user.Username, &user.UsernameNormalized, &user.PasswordHash, &user.IsAdmin, &user.CreatedAt) err := scan(&user.ID, &user.Username, &user.UsernameNormalized, &user.PasswordHash, &user.IsAdmin, &user.CreatedAt, &user.TokenVersion, &user.QuotaBytes)
return &user, err return &user, err
} }
// BumpTokenVersion invalide tous les tokens émis (V3 S6) : le middleware
// rejette les tokens dont le claim `tv` diffère. Compte absent → ErrNotFound.
func (u *Users) BumpTokenVersion(id string) error {
result, err := u.DB.Exec(
`UPDATE users SET token_version = token_version + 1, 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
}
+131
View File
@@ -0,0 +1,131 @@
package repository
import (
"database/sql"
"time"
"github.com/lib/pq"
)
// VersionRow is one frozen byte-generation of a resource.
type VersionRow struct {
ID string
VersionNo int
Size int64
MimeType string
Extension string
StoredPath string
CreatedAt time.Time
}
// MaxVersions caps the per-resource history (V3 P1 : N=3).
const MaxVersions = 3
// NextVersionNo returns 1 + the highest version number (monotonic, never
// reused even after pruning).
func (r *Resources) NextVersionNo(resourceID string) (int, error) {
var next int
err := r.DB.QueryRow(
`SELECT COALESCE(MAX(version_no), 0) + 1 FROM resource_versions WHERE resource_id = $1`,
resourceID,
).Scan(&next)
return next, err
}
// InsertVersion freezes one byte-generation. ID must be NewID() 32-hex.
func (r *Resources) InsertVersion(id, resourceID string, versionNo int, size int64, mimeType, extension *string, storedPath string) error {
_, err := r.DB.Exec(
`INSERT INTO resource_versions (id, resource_id, version_no, size_bytes, mime_type, extension, stored_path)
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
id, resourceID, versionNo, size, mimeType, extension, storedPath,
)
return err
}
// ListVersions returns the history of a resource owned by ownerID
// (ownership checked via the parent row), newest first.
func (r *Resources) ListVersions(ownerID, resourceID string) ([]VersionRow, error) {
if _, err := r.GetFile(ownerID, resourceID); err != nil {
// Folders can be versioned too (metadata only has no bytes — in
// practice only files carry versions, but don't 404 on type).
if _, ferr := r.GetFolder(ownerID, resourceID); ferr != nil {
return nil, err
}
}
rows, err := r.DB.Query(
`SELECT v.id, v.version_no, v.size_bytes, COALESCE(v.mime_type, ''),
COALESCE(v.extension, ''), v.stored_path, v.created_at
FROM resource_versions v
JOIN resources r ON r.resource_id = v.resource_id
WHERE v.resource_id = $1 AND r.user_id = $2 AND r.deleted_at IS NULL
ORDER BY v.version_no DESC`,
resourceID, ownerID,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]VersionRow, 0)
for rows.Next() {
var row VersionRow
if err := rows.Scan(&row.ID, &row.VersionNo, &row.Size, &row.MimeType, &row.Extension, &row.StoredPath, &row.CreatedAt); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
// GetVersion returns one frozen generation (owner-scoped via parent row).
func (r *Resources) GetVersion(ownerID, resourceID string, versionNo int) (VersionRow, error) {
var row VersionRow
err := r.DB.QueryRow(
`SELECT v.id, v.version_no, v.size_bytes, COALESCE(v.mime_type, ''),
COALESCE(v.extension, ''), v.stored_path, v.created_at
FROM resource_versions v
JOIN resources r ON r.resource_id = v.resource_id
WHERE v.resource_id = $1 AND v.version_no = $2 AND r.user_id = $3 AND r.deleted_at IS NULL`,
resourceID, versionNo, ownerID,
).Scan(&row.ID, &row.VersionNo, &row.Size, &row.MimeType, &row.Extension, &row.StoredPath, &row.CreatedAt)
if err == sql.ErrNoRows {
return VersionRow{}, ErrNotFound
}
return row, err
}
// PruneVersions deletes generations beyond the newest keepN, returning their
// stored paths for physical cleanup (best-effort, caller-side).
func (r *Resources) PruneVersions(resourceID string, keepN int) ([]string, error) {
rows, err := r.DB.Query(
`SELECT stored_path FROM resource_versions
WHERE resource_id = $1
ORDER BY version_no DESC OFFSET $2`,
resourceID, keepN,
)
if err != nil {
return nil, err
}
var paths []string
for rows.Next() {
var p string
if err := rows.Scan(&p); err != nil {
rows.Close()
return nil, err
}
paths = append(paths, p)
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, err
}
if len(paths) == 0 {
return nil, nil
}
if _, err := r.DB.Exec(
`DELETE FROM resource_versions WHERE resource_id = $1 AND stored_path = ANY($2)`,
resourceID, pq.Array(paths),
); err != nil {
return nil, err
}
return paths, nil
}
+155
View File
@@ -0,0 +1,155 @@
package service
import (
"encoding/json"
"fmt"
"io"
"log"
"os"
"time"
"github.com/alexmullins/zip"
)
// Export password floor (V3 S7 C3) : un backup chiffré avec "1234" est un
// placebo — même seuil que les mots de passe compte (8).
const exportMinPasswordLength = 8
// ExportMaxResources bounds a full export (V3 S7 C3) : au-delà, l'export est
// tronqué honnêtement (manifest.truncated = true) plutôt que de gonfler sans
// fin la mémoire/temps d'une requête HTTP.
const ExportMaxResources = 20000
// ExportManifestFile is the encrypted manifest inside the zip.
type ExportManifestFile struct {
Version int `json:"version"`
ExportedAt string `json:"exportedAt"`
UserID string `json:"userId"`
Truncated bool `json:"truncated"`
Folders []ExportFolderEntry `json:"folders"`
Files []ExportFileEntry `json:"files"`
}
// ExportFolderEntry mirrors a live folder (tree rebuilt via parentId).
type ExportFolderEntry struct {
ID string `json:"id"`
Name string `json:"name"`
ParentID string `json:"parentId,omitempty"`
}
// ExportFileEntry mirrors a live file (+ extracted knowledge for re-import).
type ExportFileEntry struct {
ID string `json:"id"`
Name string `json:"name"`
ParentID string `json:"parentId,omitempty"`
Size int64 `json:"size"`
MimeType string `json:"mimeType,omitempty"`
Extension string `json:"extension,omitempty"`
Hash string `json:"hash,omitempty"`
OcrText string `json:"ocrText,omitempty"`
Facts []FactDTO `json:"facts,omitempty"`
Path string `json:"path,omitempty"` // files/<id>.<ext> — absent si metadata-only
HasBytes bool `json:"hasBytes"`
}
// Export streams an AES-256 encrypted zip of the account (V3 S7 C3) : every
// entry — files AND manifest — is encrypted with password (WinZip AES, cf.
// alexmullins/zip). Scope : own live resources only (ni trashés, ni
// partagés d'autrui). Metadata-only files appear in the manifest without
// bytes (Path vide, HasBytes false). Password < 8 → error (400 côté handler).
func (s *Resources) Export(w io.Writer, ownerID, password string) error {
if len(password) < exportMinPasswordLength {
return fmt.Errorf("export password must be at least %d characters", exportMinPasswordLength)
}
folders, err := s.Repo.ExportFolders(ownerID, ExportMaxResources)
if err != nil {
return err
}
files, err := s.Repo.ExportFiles(ownerID, ExportMaxResources)
if err != nil {
return err
}
truncated := len(folders) == ExportMaxResources || len(files) == ExportMaxResources
manifest := ExportManifestFile{
Version: 1, ExportedAt: time.Now().UTC().Format(time.RFC3339),
UserID: ownerID, Truncated: truncated,
Folders: make([]ExportFolderEntry, 0, len(folders)),
Files: make([]ExportFileEntry, 0, len(files)),
}
for _, f := range folders {
manifest.Folders = append(manifest.Folders, ExportFolderEntry{
ID: f.ID, Name: f.Name, ParentID: f.ParentID,
})
}
zw := zip.NewWriter(w)
writeEncrypted := func(name string, data []byte) error {
fh := &zip.FileHeader{Name: name, Method: zip.Deflate}
fh.SetPassword(password)
fw, err := zw.CreateHeader(fh)
if err != nil {
return err
}
_, err = fw.Write(data)
return err
}
for _, f := range files {
entry := ExportFileEntry{
ID: f.ID, Name: f.Name, ParentID: f.ParentID, Size: f.Size,
MimeType: f.MimeType, Extension: f.Extension, Hash: f.Hash,
OcrText: f.OcrText,
}
// Faits joints (auto + corrections — la connaissance voyage avec).
if facts, ferr := s.Repository.Resources.ListFacts(f.ID); ferr == nil {
for _, fact := range facts {
entry.Facts = append(entry.Facts, FactDTO{
FactType: fact.Type, ValueText: fact.ValueText,
ValueNum: fact.ValueNum, ValueDate: derefString(fact.ValueDate),
Confidence: fact.Confidence, Origin: fact.Origin,
})
}
}
src, serr := s.resolvePhysical(ownerID, f.ID)
if serr != nil {
entry.HasBytes = false
manifest.Files = append(manifest.Files, entry)
continue
}
zipName := "files/" + f.ID
if f.Extension != "" {
zipName += "." + f.Extension
}
entry.Path = zipName
entry.HasBytes = true
manifest.Files = append(manifest.Files, entry)
in, err := os.Open(src)
if err != nil {
log.Printf("export: open %s: %v", f.ID, err)
continue
}
fh := &zip.FileHeader{Name: zipName, Method: zip.Deflate}
fh.SetPassword(password)
fw, err := zw.CreateHeader(fh)
if err != nil {
in.Close()
return err
}
if _, err := io.Copy(fw, in); err != nil {
in.Close()
return err
}
in.Close()
}
raw, err := json.MarshalIndent(manifest, "", " ")
if err != nil {
return err
}
if err := writeEncrypted("manifest.json", raw); err != nil {
return err
}
return zw.Close()
}
+163
View File
@@ -0,0 +1,163 @@
package service
import (
"archive/zip"
"bytes"
"encoding/json"
"testing"
azip "github.com/alexmullins/zip"
"github.com/kazier/backend/repository"
)
// TestExportRoundTrip : zip déchiffrable avec le mot de passe, manifest
// cohérent (fichiers + faits + dossiers), octets intacts, trashés exclus.
func TestExportRoundTrip(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "export-roundtrip")
folderID := repository.NewID()
if err := s.Repository.Resources.InsertFolder(userID, folderID, "Papiers", ""); err != nil {
t.Fatalf("insert folder: %v", err)
}
a, err := s.Upload(userID, multipartFileHeader(t, "a.txt", []byte("contenu-a")), folderID, "")
if err != nil {
t.Fatalf("upload a: %v", err)
}
b, err := s.Upload(userID, multipartFileHeader(t, "b.txt", []byte("contenu-b")), "", "")
if err != nil {
t.Fatalf("upload b: %v", err)
}
// Trashé : exclu de l'export.
if _, err := s.Trash(userID, b.ID); err != nil {
t.Fatalf("trash: %v", err)
}
// Metadata-only (jamais uploadé) : manifest sans octets.
metaID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, metaID, "fantome.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert meta: %v", err)
}
var buf bytes.Buffer
if err := s.Export(&buf, userID, "motdepasse-8"); err != nil {
t.Fatalf("export: %v", err)
}
if buf.Len() == 0 {
t.Fatal("zip vide")
}
// Lecture avec le bon mot de passe (lib standard : échoue sur AES —
// on relit avec la même lib, comme un outil compatible WinZip AES).
zr, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open zip: %v", err)
}
names := map[string]bool{}
var manifestRaw []byte
for _, f := range zr.File {
names[f.Name] = true
if !f.IsEncrypted() {
t.Errorf("entrée non chiffrée: %s", f.Name)
}
f.SetPassword("motdepasse-8")
rc, err := f.Open()
if err != nil {
t.Fatalf("open %s: %v", f.Name, err)
}
var content bytes.Buffer
if _, err := content.ReadFrom(rc); err != nil {
rc.Close()
t.Fatalf("read %s: %v", f.Name, err)
}
rc.Close()
switch {
case f.Name == "manifest.json":
manifestRaw = content.Bytes()
case len(content.Bytes()) > 0 && f.Name != "manifest.json":
_ = content
}
}
var manifest ExportManifestFile
if err := json.Unmarshal(manifestRaw, &manifest); err != nil {
t.Fatalf("manifest: %v", err)
}
if manifest.Version != 1 || manifest.UserID != userID || manifest.Truncated {
t.Fatalf("manifest inattendu: %+v", manifest)
}
if len(manifest.Folders) != 1 || manifest.Folders[0].Name != "Papiers" {
t.Fatalf("dossiers: %+v", manifest.Folders)
}
if len(manifest.Files) != 2 {
t.Fatalf("fichiers manifest: %+v (attendu a + fantome, b trashé exclu)", manifest.Files)
}
byID := map[string]ExportFileEntry{}
for _, f := range manifest.Files {
byID[f.ID] = f
}
if byID[a.ID].Path == "" || !byID[a.ID].HasBytes {
t.Errorf("a doit avoir des octets: %+v", byID[a.ID])
}
if byID[metaID].Path != "" || byID[metaID].HasBytes {
t.Errorf("fantome sans octets: %+v", byID[metaID])
}
if !names["manifest.json"] || !names[byID[a.ID].Path] {
t.Fatalf("entrées zip manquantes: %v", names)
}
// Contenu chiffré : illisible sans mot de passe (lib standard échoue),
// et mauvais mot de passe refusé.
stdReader, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open std: %v", err)
}
for _, f := range stdReader.File {
rc, err := f.Open()
if err == nil {
var tmp bytes.Buffer
_, copyErr := tmp.ReadFrom(rc)
rc.Close()
if copyErr == nil && tmp.Len() > 0 {
t.Errorf("contenu lisible sans mot de passe: %s", f.Name)
}
}
}
zr2, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("reopen: %v", err)
}
for _, f := range zr2.File {
if f.Name != "manifest.json" {
continue
}
f.SetPassword("mauvais-mot-de-passe")
rc, err := f.Open()
if err == nil {
var tmp bytes.Buffer
_, copyErr := tmp.ReadFrom(rc)
rc.Close()
if copyErr == nil {
t.Error("manifest déchiffré avec un mauvais mot de passe")
}
}
}
}
func TestExportPasswordFloor(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "export-pw")
var buf bytes.Buffer
if err := s.Export(&buf, userID, "court"); err == nil {
t.Fatal("mot de passe court accepté")
}
// Compte vide : zip valide avec manifest seul.
if err := s.Export(&buf, userID, "motdepasse-8"); err != nil {
t.Fatalf("export vide: %v", err)
}
zr, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open: %v", err)
}
if len(zr.File) != 1 || zr.File[0].Name != "manifest.json" {
t.Fatalf("export vide inattendu: %v", zr.File)
}
}
+196
View File
@@ -0,0 +1,196 @@
package service
import (
"fmt"
"log"
"time"
"github.com/kazier/backend/extract"
"github.com/kazier/backend/repository"
)
// Extract derives generic facts from OCR text (V3 S2) — dates, amounts,
// issuers, references, suggested doc type. Rules-based (package extract),
// no ML, no network : it runs inside the OCR worker right after Tesseract
// and stores origin='auto' rows (user corrections, origin='user', survive
// every re-run — see UpsertAutoFacts).
type Extract struct {
Repository *repository.Repository
}
func NewExtract(repo *repository.Repository) *Extract {
return &Extract{Repository: repo}
}
// FactDTO serializes one row of GET /files/:id/facts.
type FactDTO struct {
FactType string `json:"factType"`
ValueText string `json:"valueText,omitempty"`
ValueNum *float64 `json:"valueNum,omitempty"`
ValueDate string `json:"valueDate,omitempty"`
Confidence float64 `json:"confidence"`
Origin string `json:"origin"`
}
// ProcessText extracts facts from text and replaces the resource's auto
// facts. Empty text clears stale auto facts. Never touches user corrections.
// Afterwards the deterministic links are reconciled (same_issuer /
// same_reference may have appeared or vanished) — best-effort.
func (e *Extract) ProcessText(ownerID, resourceID, text string) error {
raw := extract.FromText(text)
params := make([]repository.FactParam, 0, len(raw))
for _, f := range raw {
var num *float64
if f.HasNum {
n := f.ValueNum
num = &n
}
var dat *string
if f.ValueDate != "" {
d := f.ValueDate
dat = &d
}
text := f.ValueText
// Amounts carry a display string ("1234.56 €") — keep the numeric
// column as the machine value, the text as the human one.
params = append(params, repository.FactParam{
Type: string(f.Type),
ValueText: text,
ValueNum: num,
ValueDate: dat,
Confidence: f.Confidence,
})
}
if err := e.Repository.Resources.UpsertAutoFacts(resourceID, params); err != nil {
return err
}
if err := e.Repository.Resources.ReconcileLinks(ownerID, resourceID); err != nil {
log.Printf("extract: reconcile %s: %v", resourceID, err)
}
return nil
}
// Backfill processes files with OCR text but no auto facts yet (one boot
// pass, bounded batches). Returns the number of resources processed.
func (e *Extract) Backfill(batch int) (int, error) {
total := 0
for {
pending, err := e.Repository.Resources.ListNeedingExtract(batch)
if err != nil {
return total, err
}
if len(pending) == 0 {
return total, nil
}
for _, p := range pending {
if err := e.ProcessText(p.UserID, p.ResourceID, p.Text); err != nil {
log.Printf("extract: backfill %s: %v", p.ResourceID, err)
continue
}
total++
}
}
}
// GetFacts returns the facts of a visible resource (viewer+, own or shared —
// same scope as GetFileOcr, facts derive from the OCR text). Trashed/absent/
// foreign → repository.ErrNotFound.
func (s *Resources) GetFacts(userID, resourceID string) ([]FactDTO, error) {
if _, err := s.Repo.GetFileVisible(userID, resourceID); err != nil {
return nil, err
}
rows, err := s.Repository.Resources.ListFacts(resourceID)
if err != nil {
return nil, err
}
out := make([]FactDTO, 0, len(rows))
for _, row := range rows {
out = append(out, FactDTO{
FactType: row.Type,
ValueText: row.ValueText,
ValueNum: row.ValueNum,
ValueDate: derefString(row.ValueDate),
Confidence: row.Confidence,
Origin: row.Origin,
})
}
return out, nil
}
// validFactTypes mirrors the resource_facts CHECK (migration 000019).
// Validated in Go so violations map to INVALID_REQUEST, never 500.
var validFactTypes = map[string]bool{
"date": true, "due_date": true, "period": true, "amount": true,
"issuer": true, "reference": true, "doc_type": true,
}
// ErrInvalidFact marks client fact-validation failures (400 INVALID_REQUEST,
// never 500 — cf. FEEDBACK #8). Wrapped by validateFactParam.
var ErrInvalidFact = fmt.Errorf("invalid fact")
// CorrectFacts replaces the user's correction set on a resource (S3 :
// full-replace, not a diff). Requires editor+ like update_metadata
// (A8-style : viewer- ne peut pas corriger → NOT_FOUND halt, pas d'oracle).
// Absent/trashed/foreign → repository.ErrNotFound.
func (s *Resources) CorrectFacts(userID, resourceID string, facts []FactDTO) error {
access, err := s.Repository.Shares.EffectiveAccess(userID, resourceID)
if err != nil {
return err
}
if access.EffectiveRank < repository.AccessEditor {
return repository.ErrNotFound
}
params := make([]repository.FactParam, 0, len(facts))
for i, f := range facts {
p, err := validateFactParam(i, f)
if err != nil {
return err
}
params = append(params, p)
}
if err := s.Repository.Resources.CorrectFacts(resourceID, params); err != nil {
return err
}
// Les faits ont changé : les arêtes same_issuer/same_reference suivent.
if err := s.Repository.Resources.ReconcileLinks(userID, resourceID); err != nil {
log.Printf("extract: reconcile %s: %v", resourceID, err)
}
return nil
}
func validateFactParam(i int, f FactDTO) (repository.FactParam, error) {
if !validFactTypes[f.FactType] {
return repository.FactParam{}, fmt.Errorf("facts[%d].factType invalide: %w", i, ErrInvalidFact)
}
if f.Confidence < 0 || f.Confidence > 1 {
return repository.FactParam{}, fmt.Errorf("facts[%d].confidence hors bornes [0,1]: %w", i, ErrInvalidFact)
}
var num *float64
if f.ValueNum != nil {
n := *f.ValueNum
num = &n
}
var dat *string
if f.ValueDate != "" {
if _, err := time.Parse("2006-01-02", f.ValueDate); err != nil {
return repository.FactParam{}, fmt.Errorf("facts[%d].valueDate doit être ISO YYYY-MM-DD: %w", i, ErrInvalidFact)
}
d := f.ValueDate
dat = &d
}
if f.ValueText == "" && num == nil && dat == nil {
return repository.FactParam{}, fmt.Errorf("facts[%d] sans valeur (valueText|valueNum|valueDate requis): %w", i, ErrInvalidFact)
}
conf := f.Confidence
if conf == 0 {
// Correction manuelle sans confiance explicite = affirmation.
conf = 1.0
}
return repository.FactParam{
Type: f.FactType,
ValueText: f.ValueText,
ValueNum: num,
ValueDate: dat,
Confidence: conf,
}, nil
}
+363
View File
@@ -0,0 +1,363 @@
package service
import (
"errors"
"testing"
"github.com/kazier/backend/repository"
)
func newExtractStore(t *testing.T) (*Resources, *Extract) {
t.Helper()
s := newServiceStore(t)
return s, NewExtract(s.Repository)
}
const extractCorpus = `EDF - SERVICE CLIENTS
Facture n° FA-2026-0031 du 12/03/2026
Montant total TTC : 84,20 €
À payer avant le 12/04/2026
`
func TestProcessTextPersistsAutoFacts(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-auto")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil {
t.Fatalf("process: %v", err)
}
facts, err := s.GetFacts(userID, fileID)
if err != nil {
t.Fatalf("get facts: %v", err)
}
byType := map[string][]FactDTO{}
for _, f := range facts {
byType[f.FactType] = append(byType[f.FactType], f)
if f.Origin != "auto" {
t.Errorf("origine = %q, attendu auto", f.Origin)
}
}
if len(byType["reference"]) == 0 || len(byType["amount"]) == 0 ||
len(byType["date"]) == 0 || len(byType["due_date"]) == 0 ||
len(byType["doc_type"]) == 0 {
t.Fatalf("faits manquants: %+v", byType)
}
var amount float64
for _, f := range byType["amount"] {
if f.ValueNum != nil {
amount = *f.ValueNum
}
}
if amount != 84.20 {
t.Errorf("montant = %v, attendu 84.20", amount)
}
}
func TestProcessTextPreservesUserCorrections(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-user")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
// Correction manuelle (S3, simulée en SQL) : l'auto ne doit jamais l'écraser.
if _, err := s.Repository.Resources.DB.Exec(
`INSERT INTO resource_facts (id, resource_id, fact_type, value_text, confidence, origin)
VALUES ($1, $2, 'issuer', 'Vrai Fournisseur', 1.0, 'user')`,
repository.NewID(), fileID,
); err != nil {
t.Fatalf("seed user fact: %v", err)
}
if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil {
t.Fatalf("process: %v", err)
}
// Re-passe (idempotence du remplacement auto).
if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil {
t.Fatalf("re-process: %v", err)
}
facts, err := s.GetFacts(userID, fileID)
if err != nil {
t.Fatalf("get facts: %v", err)
}
issuers := map[string]string{}
autoCount := 0
for _, f := range facts {
if f.FactType == "issuer" {
issuers[f.Origin] = f.ValueText
}
if f.Origin == "auto" {
autoCount++
}
}
if issuers["user"] != "Vrai Fournisseur" {
t.Errorf("correction user écrasée: %+v", issuers)
}
if autoCount == 0 {
t.Error("aucun fait auto après re-passe")
}
// Pas de doublons auto après deux passes.
seen := map[string]int{}
for _, f := range facts {
if f.Origin == "auto" {
seen[f.FactType+"\x00"+f.ValueText]++
}
}
for k, n := range seen {
if n > 1 {
t.Errorf("doublon auto %q x%d", k, n)
}
}
}
func TestProcessTextEmptyClearsStaleAuto(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-clear")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil {
t.Fatalf("process: %v", err)
}
if err := ex.ProcessText(userID, fileID, ""); err != nil {
t.Fatalf("clear: %v", err)
}
facts, err := s.GetFacts(userID, fileID)
if err != nil {
t.Fatalf("get facts: %v", err)
}
if len(facts) != 0 {
t.Fatalf("auto périmés non purgés: %+v", facts)
}
}
func TestGetFactsScope(t *testing.T) {
s, ex := newExtractStore(t)
owner := mustCreateUser(t, s.Repository, "extract-scope-o")
other := mustCreateUser(t, s.Repository, "extract-scope-x")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(owner, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := ex.ProcessText(owner, fileID, extractCorpus); err != nil {
t.Fatalf("process: %v", err)
}
if _, err := s.GetFacts(other, fileID); err != repository.ErrNotFound {
t.Fatalf("étranger : attendu NOT_FOUND, got %v", err)
}
if _, err := s.GetFacts(owner, repository.NewID()); err != repository.ErrNotFound {
t.Fatalf("inconnu : attendu NOT_FOUND, got %v", err)
}
if _, err := s.Trash(owner, fileID); err != nil {
t.Fatalf("trash: %v", err)
}
if _, err := s.GetFacts(owner, fileID); err != repository.ErrNotFound {
t.Fatalf("trashé : attendu NOT_FOUND, got %v", err)
}
}
func TestBackfill(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-backfill")
oldID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, oldID, "vieux.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
// OCR d'avant la V3 : texte présent, aucun fait auto.
if err := s.Repository.Resources.UpdateOcrText(userID, oldID, extractCorpus); err != nil {
t.Fatalf("ocr text: %v", err)
}
n, err := ex.Backfill(200)
if err != nil {
t.Fatalf("backfill: %v", err)
}
if n != 1 {
t.Fatalf("backfill = %d, attendu 1", n)
}
facts, err := s.GetFacts(userID, oldID)
if err != nil || len(facts) == 0 {
t.Fatalf("faits après backfill: %+v %v", facts, err)
}
// Deuxième passe : rien à faire (idempotent).
n, err = ex.Backfill(200)
if err != nil {
t.Fatalf("backfill 2: %v", err)
}
if n != 0 {
t.Fatalf("backfill 2 = %d, attendu 0", n)
}
}
func correctDTO(factType, valueText string) FactDTO {
return FactDTO{FactType: factType, ValueText: valueText, Confidence: 1.0}
}
func TestCorrectFactsReplacesUserSet(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-correct")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil {
t.Fatalf("process: %v", err)
}
// Correction : l'émetteur auto est faux, l'utilisateur le fixe.
if err := s.CorrectFacts(userID, fileID, []FactDTO{correctDTO("issuer", "Vrai Fournisseur")}); err != nil {
t.Fatalf("correct: %v", err)
}
facts, err := s.GetFacts(userID, fileID)
if err != nil {
t.Fatalf("get facts: %v", err)
}
var userIssuer, autoIssuer int
for _, f := range facts {
if f.FactType == "issuer" && f.Origin == "user" && f.ValueText == "Vrai Fournisseur" {
userIssuer++
}
if f.FactType == "issuer" && f.Origin == "auto" {
autoIssuer++
}
}
if userIssuer != 1 {
t.Fatalf("correction user manquante: %+v", facts)
}
if autoIssuer == 0 {
t.Error("l'auto doit survivre à côté du user (les deux sont lus, user d'abord)")
}
// Deuxième correction (jeu vide) : efface les corrections, garde l'auto.
if err := s.CorrectFacts(userID, fileID, nil); err != nil {
t.Fatalf("clear corrections: %v", err)
}
facts, _ = s.GetFacts(userID, fileID)
for _, f := range facts {
if f.Origin == "user" {
t.Fatalf("corrections restantes: %+v", facts)
}
}
if len(facts) == 0 {
t.Fatal("l'auto doit survivre à l'effacement des corrections")
}
}
func TestCorrectFactsValidation(t *testing.T) {
s, _ := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-correct-val")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
num := 12.5
cases := []struct {
name string
facts []FactDTO
}{
{"type inconnu", []FactDTO{{FactType: "couleur", ValueText: "bleu"}}},
{"confiance hors bornes", []FactDTO{{FactType: "issuer", ValueText: "X", Confidence: 2}}},
{"date non ISO", []FactDTO{{FactType: "date", ValueDate: "12/03/2026"}}},
{"sans valeur", []FactDTO{{FactType: "issuer"}}},
}
for _, tc := range cases {
if err := s.CorrectFacts(userID, fileID, tc.facts); err == nil {
t.Errorf("%s : erreur attendue", tc.name)
} else if !errors.Is(err, ErrInvalidFact) {
t.Errorf("%s : attendu ErrInvalidFact, got %v", tc.name, err)
}
}
// Valides : date ISO + montant numérique.
if err := s.CorrectFacts(userID, fileID, []FactDTO{
{FactType: "due_date", ValueDate: "2026-04-12"},
{FactType: "amount", ValueNum: &num},
}); err != nil {
t.Fatalf("faits valides rejetés: %v", err)
}
}
func TestCorrectFactsScope(t *testing.T) {
s, _ := newExtractStore(t)
owner := mustCreateUser(t, s.Repository, "extract-corr-o")
viewer := mustCreateUser(t, s.Repository, "extract-corr-v")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(owner, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
// Étranger (même viewer via partage simulé plus bas) → NOT_FOUND.
if err := s.CorrectFacts(viewer, fileID, nil); err != repository.ErrNotFound {
t.Fatalf("étranger : attendu NOT_FOUND, got %v", err)
}
// Absent → NOT_FOUND (EffectiveAccess sur ressource inconnue).
if err := s.CorrectFacts(owner, repository.NewID(), []FactDTO{correctDTO("issuer", "X")}); err != repository.ErrNotFound {
t.Fatalf("absent : attendu NOT_FOUND, got %v", err)
}
}
func TestSyncOpCorrectFacts(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "extract-op")
other := mustCreateUser(t, s.Repository, "extract-op-x")
device := mustRegisterDevice(t, s.Repository, "c0000000000000000000000000000001")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil {
t.Fatalf("process: %v", err)
}
foreignID := repository.NewID()
if err := s.Repository.Resources.InsertFile(other, foreignID, "autre.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert foreign: %v", err)
}
apply := func(resID string, facts []FactDTO) SyncResult {
t.Helper()
raw := map[string]any{"facts": facts}
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), resID, OpCorrectFacts, "file", raw),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
return res
}
if res := apply(fileID, []FactDTO{correctDTO("issuer", "Corrigé")}); res.Applied != 1 || res.Failed != nil {
t.Fatalf("correct op: %+v", res)
}
facts, _ := s.GetFacts(userID, fileID)
found := false
for _, f := range facts {
if f.FactType == "issuer" && f.Origin == "user" && f.ValueText == "Corrigé" {
found = true
}
}
if !found {
t.Fatalf("correction via op manquante: %+v", facts)
}
// Op étrangère → halt NOT_FOUND.
if res := apply(foreignID, []FactDTO{correctDTO("issuer", "X")}); res.Failed == nil || res.Failed.Code != "NOT_FOUND" {
t.Fatalf("correct autrui doit halter NOT_FOUND: %+v", res)
}
// Payload invalide → halt INVALID_REQUEST.
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCorrectFacts, "file", map[string]any{
"facts": []any{map[string]any{"factType": "couleur", "valueText": "bleu"}},
}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Failed == nil || res.Failed.Code != "INVALID_REQUEST" {
t.Fatalf("payload invalide doit halter INVALID_REQUEST: %+v", res)
}
}
+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)
}
}
+228
View File
@@ -0,0 +1,228 @@
package service
import (
"crypto/sha256"
"encoding/hex"
"errors"
"io"
"log"
"os"
"path/filepath"
"strings"
"github.com/kazier/backend/repository"
)
// RelationDTO serializes one edge of GET /files/:id/relations (V3 S5).
type RelationDTO struct {
ID string `json:"id"`
OtherID string `json:"otherId"`
Type string `json:"type"`
Confidence float64 `json:"confidence"`
CreatedBy string `json:"createdBy"`
OtherName string `json:"otherName"`
OtherType string `json:"otherType"`
OtherSize int64 `json:"otherSize"`
}
// validLinkTypes mirrors the resource_links CHECK (migration 000021).
var validLinkTypes = map[string]bool{
repository.LinkSameScan: true,
repository.LinkDuplicateOf: true,
repository.LinkSameIssuer: true,
repository.LinkSameReference: true,
}
// ListRelations reconciles then returns the live edges of an owned resource
// (owner-only : shared docs don't expose the owner's graph, S5 scope).
func (s *Resources) ListRelations(ownerID, resourceID string) ([]RelationDTO, error) {
owned, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return nil, err
}
if !owned {
return nil, repository.ErrNotFound
}
if err := s.Repo.ReconcileLinks(ownerID, resourceID); err != nil {
return nil, err
}
rows, err := s.Repo.ListLinks(resourceID)
if err != nil {
return nil, err
}
out := make([]RelationDTO, 0, len(rows))
for _, row := range rows {
out = append(out, RelationDTO{
ID: row.ID, OtherID: row.OtherID, Type: row.Type,
Confidence: row.Confidence, CreatedBy: row.CreatedBy,
OtherName: row.OtherName, OtherType: row.OtherType, OtherSize: row.OtherSize,
})
}
return out, nil
}
// LinkVerdict records an explicit verdict on an edge (owner-only, both ends
// owned-live). Confirm → 1.0, invalidate → 0.0 (kept, blocks re-creation).
func (s *Resources) LinkVerdict(ownerID, resourceID, otherID, linkType string, confirmed bool) error {
if !validLinkTypes[linkType] {
return ErrInvalidLinkType
}
if otherID == resourceID {
return ErrInvalidLinkType
}
for _, id := range []string{resourceID, otherID} {
owned, err := s.Repo.ExistsOwner(ownerID, id)
if err != nil {
return err
}
if !owned {
return repository.ErrNotFound
}
}
return s.Repo.SetUserVerdict(resourceID, otherID, linkType, confirmed)
}
// DuplicateGroupDTO serializes one set of byte-identical files (B2).
type DuplicateGroupDTO struct {
ContentHash string `json:"contentHash"`
Count int `json:"count"`
TotalBytes int64 `json:"totalBytes"`
ReclaimableBytes int64 `json:"reclaimableBytes"`
Files []DuplicateFileDTO `json:"files"`
}
// DuplicateFileDTO serializes one member (newest first).
type DuplicateFileDTO struct {
ID string `json:"id"`
Name string `json:"name"`
Size int64 `json:"size"`
UpdatedAt int64 `json:"updatedAt"`
}
// ListDuplicates returns the owner's byte-identical file sets, biggest
// first. Owner scope (own files only) — `[]` when clean.
func (s *Resources) ListDuplicates(ownerID string) ([]DuplicateGroupDTO, error) {
groups, err := s.Repo.ListDuplicateGroups(ownerID)
if err != nil {
return nil, err
}
out := make([]DuplicateGroupDTO, 0, len(groups))
for _, g := range groups {
dto := DuplicateGroupDTO{
ContentHash: g.ContentHash, Count: g.Count,
TotalBytes: g.TotalBytes, ReclaimableBytes: g.ReclaimableBytes,
Files: make([]DuplicateFileDTO, 0, len(g.Files)),
}
for _, f := range g.Files {
dto.Files = append(dto.Files, DuplicateFileDTO{
ID: f.ID, Name: f.Name, Size: f.Size, UpdatedAt: f.UpdatedAt,
})
}
out = append(out, dto)
}
return out, nil
}
// ErrInvalidLinkType marks client verdict-validation failures (400).
var ErrInvalidLinkType = errors.New("invalid link type or pair")
// hashPhysical computes the SHA-256 of the live bytes (safe resolution,
// same pattern as OpenContent). Absent → ErrNotFound.
func (s *Resources) hashPhysical(ownerID, resourceID string) (string, error) {
resolved, err := s.resolvePhysical(ownerID, resourceID)
if err != nil {
return "", err
}
f, err := os.Open(resolved)
if err != nil {
return "", err
}
defer f.Close()
h := sha256.New()
if _, err := io.Copy(h, f); err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}
// resolvePhysical returns the absolute path of the live bytes (safe :
// 32-hex only, regular file, symlink contained in UploadDir).
// Absent → repository.ErrNotFound.
func (s *Resources) resolvePhysical(ownerID, resourceID string) (string, error) {
if !idPattern.MatchString(ownerID) || !idPattern.MatchString(resourceID) {
return "", repository.ErrNotFound
}
base, err := filepath.EvalSymlinks(s.UploadDir)
if err != nil {
return "", err
}
matches, err := filepath.Glob(filepath.Join(s.UploadDir, ownerID, resourceID+".*"))
if err != nil {
return "", err
}
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
}
return resolved, nil
}
return "", repository.ErrNotFound
}
// refreshContentHash (re)computes and stores the hash after bytes arrive.
// Best-effort : un échec ne fait jamais échouer l'upload (loggé).
func (s *Resources) refreshContentHash(ownerID, resourceID string) {
hash, err := s.hashPhysical(ownerID, resourceID)
if err != nil {
return
}
if err := s.Repo.SetContentHash(ownerID, resourceID, hash); err != nil {
log.Printf("content: SetContentHash(%s): %v", resourceID, err)
return
}
// Des octets identiques à une autre ressource = doublon à relier.
if err := s.Repo.ReconcileLinks(ownerID, resourceID); err != nil {
log.Printf("content: reconcile(%s): %v", resourceID, err)
}
}
// BackfillHashes hashes live files missing content_hash (bounded batches,
// boot pass — uploads d'avant la V3). Returns files hashed.
func (s *Resources) BackfillHashes(batch int) (int, error) {
total := 0
for {
pending, err := s.Repo.ListMissingHashes(batch)
if err != nil {
return total, err
}
if len(pending) == 0 {
return total, nil
}
for _, p := range pending {
hash, err := s.hashPhysical(p.UserID, p.ResourceID)
if err != nil {
continue // metadata-only : rien à hasher, re-tenté au prochain upload.
}
if err := s.Repo.SetContentHash(p.UserID, p.ResourceID, hash); err != nil {
log.Printf("content: backfill hash %s: %v", p.ResourceID, err)
continue
}
if err := s.Repo.ReconcileLinks(p.UserID, p.ResourceID); err != nil {
log.Printf("content: backfill reconcile %s: %v", p.ResourceID, err)
}
total++
}
}
}
+252
View File
@@ -0,0 +1,252 @@
package service
import (
"errors"
"testing"
"github.com/kazier/backend/repository"
)
func mustLinkFile(t *testing.T, s *Resources, userID, name string) string {
t.Helper()
id := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, id, name, "", 0, nil, nil); err != nil {
t.Fatalf("insert %q: %v", name, err)
}
return id
}
func relationTypes(rels []RelationDTO) map[string]int {
out := map[string]int{}
for _, r := range rels {
out[r.Type]++
}
return out
}
func TestSameScanViaOutbox(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "links-scan")
device := mustRegisterDevice(t, s.Repository, "d0000000000000000000000000000001")
session := repository.NewID()
page1 := repository.NewID()
page2 := repository.NewID()
create := func(opID, resID, name string) {
t.Helper()
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(opID, resID, OpCreateResource, "file", map[string]any{
"name": resID + "-" + name, "scanSessionId": session,
}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Applied != 1 || res.Failed != nil {
t.Fatalf("create %s: %+v", name, res)
}
}
create(repository.NewID(), page1, "p1.png")
create(repository.NewID(), page2, "p2.png")
rels, err := s.ListRelations(userID, page1)
if err != nil {
t.Fatalf("relations: %v", err)
}
if relationTypes(rels)[repository.LinkSameScan] != 1 || rels[0].OtherID != page2 {
t.Fatalf("same_scan manquant: %+v", rels)
}
if rels[0].Confidence != 1.0 || rels[0].CreatedBy != "auto" {
t.Fatalf("arête same_scan inattendue: %+v", rels[0])
}
// Session invalide → halt INVALID_REQUEST (pas d'écriture partielle).
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), repository.NewID(), OpCreateResource, "file", map[string]any{
"name": "bad.png", "scanSessionId": "nope",
}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Failed == nil || res.Failed.Code != "INVALID_REQUEST" {
t.Fatalf("session invalide doit halter: %+v", res)
}
}
func TestDuplicateOfViaUploadHash(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "links-dupe")
a, err := s.Upload(userID, multipartFileHeader(t, "a.txt", []byte("meme-contenu")), "", "")
if err != nil {
t.Fatalf("upload a: %v", err)
}
b, err := s.Upload(userID, multipartFileHeader(t, "b.txt", []byte("meme-contenu")), "", "")
if err != nil {
t.Fatalf("upload b: %v", err)
}
rels, err := s.ListRelations(userID, a.ID)
if err != nil {
t.Fatalf("relations: %v", err)
}
if relationTypes(rels)[repository.LinkDuplicateOf] != 1 || rels[0].OtherID != b.ID {
t.Fatalf("duplicate_of manquant: %+v", rels)
}
// Contenu différent → pas de doublon.
c, err := s.Upload(userID, multipartFileHeader(t, "c.txt", []byte("autre-contenu")), "", "")
if err != nil {
t.Fatalf("upload c: %v", err)
}
relsC, err := s.ListRelations(userID, c.ID)
if err != nil {
t.Fatalf("relations c: %v", err)
}
if len(relsC) != 0 {
t.Fatalf("faux doublon: %+v", relsC)
}
}
func TestSameIssuerViaFacts(t *testing.T) {
s, ex := newExtractStore(t)
userID := mustCreateUser(t, s.Repository, "links-issuer")
f1 := mustLinkFile(t, s, userID, "f1.pdf")
f2 := mustLinkFile(t, s, userID, "f2.pdf")
if err := ex.ProcessText(userID, f1, "EDF\nFacture 10,00 €\n"); err != nil {
t.Fatalf("extract f1: %v", err)
}
if err := ex.ProcessText(userID, f2, "EDF\nFacture 20,00 €\n"); err != nil {
t.Fatalf("extract f2: %v", err)
}
rels, err := s.ListRelations(userID, f1)
if err != nil {
t.Fatalf("relations: %v", err)
}
if relationTypes(rels)[repository.LinkSameIssuer] != 1 {
t.Fatalf("same_issuer manquant: %+v", rels)
}
// Correction de l'émetteur → l'arête disparaît (prune auto).
if err := s.CorrectFacts(userID, f2, []FactDTO{{FactType: "issuer", ValueText: "ENGIE", Confidence: 1}}); err != nil {
t.Fatalf("correct: %v", err)
}
rels, err = s.ListRelations(userID, f1)
if err != nil {
t.Fatalf("relations 2: %v", err)
}
if relationTypes(rels)[repository.LinkSameIssuer] != 0 {
t.Fatalf("arête périmée non élaguée: %+v", rels)
}
}
func TestLinkVerdict(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "links-verdict")
other := mustCreateUser(t, s.Repository, "links-verdict-x")
device := mustRegisterDevice(t, s.Repository, "d0000000000000000000000000000002")
session := repository.NewID()
p1, p2 := repository.NewID(), repository.NewID()
for _, id := range []string{p1, p2} {
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), id, OpCreateResource, "file", map[string]any{
"name": id, "scanSessionId": session,
}),
})
if err != nil || res.Applied != 1 || res.Failed != nil {
t.Fatalf("create %s: %+v %v", id, res, err)
}
}
// Invalider : l'arête reste (confiance 0, verdict user) mais ne bloque rien.
if err := s.LinkVerdict(userID, p1, p2, repository.LinkSameScan, false); err != nil {
t.Fatalf("verdict: %v", err)
}
rels, _ := s.ListRelations(userID, p1)
if len(rels) != 1 || rels[0].Confidence != 0 || rels[0].CreatedBy != "user" {
t.Fatalf("verdict infirme inattendu: %+v", rels)
}
// Re-reconcile ne ressuscite pas l'arête invalidée.
rels, _ = s.ListRelations(userID, p1)
if len(rels) != 1 || rels[0].Confidence != 0 {
t.Fatalf("arête invalidée ressuscitée: %+v", rels)
}
// Re-confirmer : retour à 1.0 user.
if err := s.LinkVerdict(userID, p1, p2, repository.LinkSameScan, true); err != nil {
t.Fatalf("re-verdict: %v", err)
}
rels, _ = s.ListRelations(userID, p1)
if len(rels) != 1 || rels[0].Confidence != 1.0 || rels[0].CreatedBy != "user" {
t.Fatalf("re-verdict inattendu: %+v", rels)
}
// Type inconnu → erreur 400-candidate ; paire réflexive idem.
if err := s.LinkVerdict(userID, p1, p2, "copains", true); !errors.Is(err, ErrInvalidLinkType) {
t.Fatalf("type inconnu : attendu ErrInvalidLinkType, got %v", err)
}
if err := s.LinkVerdict(userID, p1, p1, repository.LinkSameScan, true); !errors.Is(err, ErrInvalidLinkType) {
t.Fatalf("paire réflexive : attendu ErrInvalidLinkType, got %v", err)
}
// Autrui → NOT_FOUND (pas d'oracle).
foreign := mustLinkFile(t, s, other, "x.pdf")
if err := s.LinkVerdict(other, foreign, p1, repository.LinkSameScan, true); err != repository.ErrNotFound {
t.Fatalf("verdict trans-compte : attendu NOT_FOUND, got %v", err)
}
if _, err := s.ListRelations(other, p1); err != repository.ErrNotFound {
t.Fatalf("lecture trans-compte : attendu NOT_FOUND, got %v", err)
}
}
func TestListDuplicates(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "links-dupes")
other := mustCreateUser(t, s.Repository, "links-dupes-x")
a, err := s.Upload(userID, multipartFileHeader(t, "a.txt", []byte("doublon")), "", "")
if err != nil {
t.Fatalf("upload a: %v", err)
}
b, err := s.Upload(userID, multipartFileHeader(t, "b.txt", []byte("doublon")), "", "")
if err != nil {
t.Fatalf("upload b: %v", err)
}
if _, err := s.Upload(userID, multipartFileHeader(t, "c.txt", []byte("unique-contenu")), "", ""); err != nil {
t.Fatalf("upload c: %v", err)
}
// Même contenu chez un autre compte : pas mon doublon.
if _, err := s.Upload(other, multipartFileHeader(t, "z.txt", []byte("doublon")), "", ""); err != nil {
t.Fatalf("upload other: %v", err)
}
groups, err := s.ListDuplicates(userID)
if err != nil {
t.Fatalf("duplicates: %v", err)
}
if len(groups) != 1 || groups[0].Count != 2 {
t.Fatalf("groupes inattendus: %+v", groups)
}
g := groups[0]
if g.TotalBytes != 14 || g.ReclaimableBytes != 7 {
t.Fatalf("tailles inattendues: %+v", g)
}
ids := map[string]bool{}
for _, f := range g.Files {
ids[f.ID] = true
}
if !ids[a.ID] || !ids[b.ID] {
t.Fatalf("membres inattendus: %+v", g.Files)
}
// Compte propre → [] (jamais null).
empty, err := s.ListDuplicates(other)
if err != nil {
t.Fatalf("duplicates other: %v", err)
}
if len(empty) != 0 {
t.Fatalf("compte sans doublon: %+v", empty)
}
}
+25 -1
View File
@@ -41,6 +41,11 @@ type Ocr struct {
Lang string Lang string
Engine ocr.Engine Engine ocr.Engine
StaleAfter time.Duration StaleAfter time.Duration
// OnText, quand non-nil, reçoit chaque texte extrait avec succès (V3 S2 :
// le service Extract en dérive des faits génériques). Appelé dans le
// worker, jamais dans un handler ; une erreur est loggée, pas propagée
// (le job OCR reste `done` — l'extract est un enrichissement, pas un gate).
OnText func(userID, resourceID, text string)
} }
func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr { func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr {
@@ -166,9 +171,10 @@ func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
fail(err.Error()) fail(err.Error())
return return
} }
trimmed := strings.TrimSpace(text)
// Le texte atterrit sur la ressource (updated_at bumpé) : consultable par // Le texte atterrit sur la ressource (updated_at bumpé) : consultable par
// tous les devices du user et les grantees via GET /files/:id/ocr. // tous les devices du user et les grantees via GET /files/:id/ocr.
if trimmed := strings.TrimSpace(text); trimmed != "" { if trimmed != "" {
if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil { if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil {
if errors.Is(err, repository.ErrNotFound) { if errors.Is(err, repository.ErrNotFound) {
fail("file not readable") fail("file not readable")
@@ -178,9 +184,27 @@ func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
return return
} }
} }
// V3 S2 : faits génériques (même texte vide — purge les auto périmés).
if o.OnText != nil {
// userID capturing : le user courant, pas un owner résolu plus tard.
if terr := o.safeOnText(userID, row.FileID, trimmed); terr != nil {
log.Printf("ocr: extract %s: %v", row.FileID, terr)
}
}
complete(text) complete(text)
} }
// safeOnText isole un hook OnText paniquant (règle défectueuse) du worker.
func (o *Ocr) safeOnText(userID, resourceID, text string) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("extract panic: %v", r)
}
}()
o.OnText(userID, resourceID, text)
return nil
}
// physicalPath résout UPLOAD_DIR/<user_id>/<resource_id>.<ext> — l'ext est // physicalPath résout UPLOAD_DIR/<user_id>/<resource_id>.<ext> — l'ext est
// choisi à l'upload, le fichier réel est retrouvé par préfixe. Durci (A12) : // choisi à l'upload, le fichier réel est retrouvé par préfixe. Durci (A12) :
// identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier // identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier
+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
}
+220
View File
@@ -0,0 +1,220 @@
package service
import (
"bytes"
"context"
"errors"
"fmt"
"image"
"image/gif"
"image/jpeg"
"image/png"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"golang.org/x/image/draw"
"golang.org/x/image/webp"
)
// ErrNoPreview signale qu'aucune vignette n'est possible (type non supporté,
// outil absent, octets illisibles). Handlers → 404 NO_PREVIEW (l'UI montre
// l'icône de catégorie au lieu de réessayer).
var ErrNoPreview = errors.New("no preview available")
// MaxPreviewEdge borne la vignette (miroir ThumbnailStore mobile, 512 px).
const MaxPreviewEdge = 512
// previewJPEGQuality compresse les vignettes (galerie rapide, artefacts invisibles à 512 px).
const previewJPEGQuality = 80
// pdftoppmTimeout borne le rendu PDF (binaire externe, jamais bloquant).
const pdftoppmTimeout = 30 * time.Second
// OpenPreview résout la vignette JPEG d'un fichier visible (viewer+, own ou
// shared) : cache `.previews/<resource_id>.jpg` régénéré quand la source a
// changé (taille ou updated_at), sinon servi tel quel. Images : pur Go.
// PDF page 1 : `pdftoppm` (poppler, cf. Dockerfile) ; absent → ErrNoPreview.
func (s *Resources) OpenPreview(userID, resourceID string) (string, error) {
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return "", err
}
dir := filepath.Join(s.UploadDir, ".previews")
cached := filepath.Join(dir, resourceID+".jpg")
if prev, err := s.Repo.GetPreview(resourceID); err == nil {
if prev.SrcSize == row.Size && prev.SrcUpdatedAt.Equal(row.UpdatedAt) {
if fi, serr := os.Stat(cached); serr == nil && fi.Mode().IsRegular() {
return cached, nil
}
}
}
info, err := s.OpenContent(userID, resourceID)
if err != nil {
return "", err
}
kind := previewKind(row.MimeType, info.Path)
var data []byte
switch kind {
case "image":
data, err = renderImagePreview(info.Path)
case "pdf":
data, err = renderPDFPreview(info.Path)
default:
return "", ErrNoPreview
}
if err != nil {
return "", err
}
if err := os.MkdirAll(dir, 0o700); err != nil {
return "", fmt.Errorf("preview dir: %w", err)
}
tmp, err := os.CreateTemp(dir, ".tmp-"+resourceID+".*.jpg")
if err != nil {
return "", fmt.Errorf("preview tmp: %w", err)
}
tmpName := tmp.Name()
if _, err := tmp.Write(data); err != nil {
tmp.Close()
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview write: %w", err)
}
if err := tmp.Close(); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview close: %w", err)
}
if err := os.Chmod(tmpName, 0o600); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview chmod: %w", err)
}
if err := os.Rename(tmpName, cached); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview commit: %w", err)
}
if err := s.Repo.UpsertPreview(resourceID, row.Size, row.UpdatedAt); err != nil {
log.Printf("preview: upsert(%s): %v", resourceID, err)
}
return cached, nil
}
// previewKind classe la source : images décodables Go vs PDF vs le reste.
func previewKind(mimeType, path string) string {
mime := strings.ToLower(mimeType)
if strings.HasPrefix(mime, "image/") {
return "image"
}
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(path), "."))
switch ext {
case "jpg", "jpeg", "png", "gif", "webp", "bmp":
return "image"
case "pdf":
return "pdf"
}
if mime == "application/pdf" {
return "pdf"
}
return ""
}
// renderImagePreview décode (jpeg/png/gif/webp) et réduit au plus grand côté
// MaxPreviewEdge, sortie JPEG. Source déjà à taille → ré-encodée telle quelle
// (uniformité du cache, coût négligeable à cette échelle).
func renderImagePreview(path string) ([]byte, error) {
f, err := os.Open(path)
if err != nil {
return nil, ErrNoPreview
}
defer f.Close()
var img image.Image
lower := strings.ToLower(path)
switch {
case strings.HasSuffix(lower, ".png"):
img, err = png.Decode(f)
case strings.HasSuffix(lower, ".gif"):
img, err = gif.Decode(f)
case strings.HasSuffix(lower, ".webp"):
img, err = webp.Decode(f)
default:
img, err = jpeg.Decode(f)
if err != nil {
// Extension menteuse (ex. .jpg contenant du PNG) : tente le PNG.
if _, serr := f.Seek(0, io.SeekStart); serr == nil {
img, err = png.Decode(f)
}
}
}
if err != nil {
return nil, ErrNoPreview
}
return encodeScaled(img)
}
// renderPDFPreview rend la page 1 via `pdftoppm` (poppler) puis réduit.
// Binaire absent ou PDF illisible → ErrNoPreview (jamais 500).
func renderPDFPreview(path string) ([]byte, error) {
if _, err := exec.LookPath("pdftoppm"); err != nil {
return nil, ErrNoPreview
}
dir, err := os.MkdirTemp("", "kazier-preview-*")
if err != nil {
return nil, fmt.Errorf("preview tmpdir: %w", err)
}
defer os.RemoveAll(dir)
prefix := filepath.Join(dir, "page")
ctx, cancel := context.WithTimeout(context.Background(), pdftoppmTimeout)
defer cancel()
// -r 50 : assez pour 512 px après réduction, sans pic mémoire.
cmd := exec.CommandContext(ctx, "pdftoppm", "-jpeg", "-r", "50", "-f", "1", "-l", "1", "-singlefile", path, prefix)
if out, err := cmd.CombinedOutput(); err != nil {
log.Printf("preview: pdftoppm: %v (%s)", err, strings.TrimSpace(string(out)))
return nil, ErrNoPreview
}
rendered := prefix + ".jpg"
f, err := os.Open(rendered)
if err != nil {
return nil, ErrNoPreview
}
defer f.Close()
img, err := jpeg.Decode(f)
if err != nil {
return nil, ErrNoPreview
}
return encodeScaled(img)
}
// encodeScaled réduit au plus grand côté MaxPreviewEdge (ratio préservé) et
// encode en JPEG. Images déjà petites : recopiées à l'identique.
func encodeScaled(img image.Image) ([]byte, error) {
bounds := img.Bounds()
w, h := bounds.Dx(), bounds.Dy()
if w <= 0 || h <= 0 {
return nil, ErrNoPreview
}
scaled := img
max := w
if h > max {
max = h
}
if max > MaxPreviewEdge {
ratio := float64(MaxPreviewEdge) / float64(max)
nw, nh := int(float64(w)*ratio+0.5), int(float64(h)*ratio+0.5)
if nw < 1 {
nw = 1
}
if nh < 1 {
nh = 1
}
dst := image.NewRGBA(image.Rect(0, 0, nw, nh))
draw.CatmullRom.Scale(dst, dst.Bounds(), img, bounds, draw.Over, nil)
scaled = dst
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, scaled, &jpeg.Options{Quality: previewJPEGQuality}); err != nil {
return nil, fmt.Errorf("preview encode: %w", err)
}
return buf.Bytes(), nil
}
+160
View File
@@ -0,0 +1,160 @@
package service
import (
"bytes"
"image"
"image/color"
"image/jpeg"
"image/png"
"os"
"os/exec"
"path/filepath"
"testing"
"github.com/kazier/backend/dbtest"
"github.com/kazier/backend/repository"
)
// newPreviewStore : comme newServiceStore mais avec un quota d'upload réaliste
// (les images de test dépassent les 100 octets du store par défaut).
func newPreviewStore(t *testing.T) *Resources {
t.Helper()
conn := dbtest.OpenTestDatabase(t, serviceTestURL)
repo := repository.NewRepository(conn)
return NewResources(repo, t.TempDir(), 10<<20)
}
// testImageBytes génère un JPEG 800x600 uni (décodable sans fixture).
func testImageBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 800, 600))
for y := 0; y < 600; y++ {
for x := 0; x < 800; x++ {
img.Set(x, y, color.RGBA{uint8(x % 256), uint8(y % 256), 128, 255})
}
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, nil); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
func TestOpenPreviewImage(t *testing.T) {
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-img")
dto, err := s.Upload(userID, multipartFileHeader(t, "photo.jpg", testImageBytes(t)), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
path, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview: %v", err)
}
f, err := os.Open(path)
if err != nil {
t.Fatalf("open preview: %v", err)
}
defer f.Close()
img, err := jpeg.Decode(f)
if err != nil {
t.Fatalf("preview n'est pas un JPEG: %v", err)
}
b := img.Bounds()
if b.Dx() > MaxPreviewEdge || b.Dy() > MaxPreviewEdge {
t.Fatalf("vignette trop grande: %dx%d", b.Dx(), b.Dy())
}
if b.Dx() != MaxPreviewEdge {
t.Fatalf("plus grand côté = %d, attendu %d", b.Dx(), MaxPreviewEdge)
}
// Second appel : cache (même fichier, pas de régénération).
fi1, _ := os.Stat(path)
path2, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview 2: %v", err)
}
fi2, _ := os.Stat(path2)
if !os.SameFile(fi1, fi2) {
t.Fatal("le cache aurait dû être servi")
}
// Overwrite → la vignette suit les nouveaux octets.
dto2, err := s.Upload(userID, multipartFileHeader(t, "photo.jpg", testImageBytes(t)), "", dto.ID)
if err != nil {
t.Fatalf("overwrite: %v", err)
}
_ = dto2
path3, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview 3: %v", err)
}
fi3, _ := os.Stat(path3)
if os.SameFile(fi2, fi3) {
t.Fatal("la vignette aurait dû être régénérée après overwrite")
}
}
func TestOpenPreviewUnsupported(t *testing.T) {
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-no")
dto, err := s.Upload(userID, multipartFileHeader(t, "notes.txt", []byte("hello")), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
if _, err := s.OpenPreview(userID, dto.ID); err != ErrNoPreview {
t.Fatalf("txt : attendu ErrNoPreview, got %v", err)
}
// Trashé → NOT_FOUND (pas NO_PREVIEW : invisible d'abord).
if _, err := s.Trash(userID, dto.ID); err != nil {
t.Fatalf("trash: %v", err)
}
if _, err := s.OpenPreview(userID, dto.ID); err != repository.ErrNotFound {
t.Fatalf("trashé : attendu NOT_FOUND, got %v", err)
}
// Étranger → NOT_FOUND.
other := mustCreateUser(t, s.Repository, "preview-no-x")
dto2, err := s.Upload(other, multipartFileHeader(t, "img.png", testPNGBytes(t)), "", "")
if err != nil {
t.Fatalf("upload other: %v", err)
}
if _, err := s.OpenPreview(userID, dto2.ID); err != repository.ErrNotFound {
t.Fatalf("étranger : attendu NOT_FOUND, got %v", err)
}
}
func testPNGBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 100, 100))
var buf bytes.Buffer
if err := png.Encode(&buf, img); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
func TestOpenPreviewPDF(t *testing.T) {
if _, err := exec.LookPath("pdftoppm"); err != nil {
t.Skip("pdftoppm absent (hors Docker) — rendu PDF non testé ici")
}
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-pdf")
pdf := []byte("%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 200 200]>>endobj\ntrailer<</Root 1 0 R>>\n")
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.pdf", pdf), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
path, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview pdf: %v", err)
}
if fi, err := os.Stat(path); err != nil || fi.Size() == 0 {
t.Fatalf("vignette pdf absente: %v", err)
}
_ = filepath.Separator
}
+202 -22
View File
@@ -18,20 +18,25 @@ import (
// ErrFileTooLarge signals an upload above MaxFileSize. // ErrFileTooLarge signals an upload above MaxFileSize.
var ErrFileTooLarge = errors.New("file too large") var ErrFileTooLarge = errors.New("file too large")
// ErrQuotaExceeded signals an upload that would overflow the account quota
// (V3 S6 A2). Handlers map it to 413 QUOTA_EXCEEDED (never 500).
var ErrQuotaExceeded = errors.New("storage quota exceeded")
// ErrInvalidUpload signals a rejected upload (display name or path component). // ErrInvalidUpload signals a rejected upload (display name or path component).
// Handlers map it to 400 INVALID_REQUEST (never 500). // Handlers map it to 400 INVALID_REQUEST (never 500).
var ErrInvalidUpload = errors.New("invalid upload name") var ErrInvalidUpload = errors.New("invalid upload name")
// FileDTO serializes exactly as mobile/api/types.ts FileDto. // FileDTO serializes exactly as mobile/api/types.ts FileDto.
type FileDTO struct { type FileDTO struct {
ID string `json:"id"` ID string `json:"id"`
Name string `json:"name"` Name string `json:"name"`
Size int64 `json:"size"` Size int64 `json:"size"`
MimeType string `json:"mimeType,omitempty"` MimeType string `json:"mimeType,omitempty"`
FolderID string `json:"folderId,omitempty"` FolderID string `json:"folderId,omitempty"`
Tags []string `json:"tags,omitempty"` Tags []string `json:"tags,omitempty"`
CreatedAt string `json:"createdAt,omitempty"` HasContent bool `json:"hasContent"`
UpdatedAt string `json:"updatedAt,omitempty"` CreatedAt string `json:"createdAt,omitempty"`
UpdatedAt string `json:"updatedAt,omitempty"`
} }
// FolderDTO serializes exactly as mobile/api/types.ts FolderDto. // FolderDTO serializes exactly as mobile/api/types.ts FolderDto.
@@ -146,6 +151,79 @@ type FileOcrDTO struct {
UpdatedAt string `json:"updatedAt,omitempty"` UpdatedAt string `json:"updatedAt,omitempty"`
} }
// ContentInfo describes the physical bytes of a file the user can see
// (viewer+, own or shared) for GET /files/:id/content (streaming lecture,
// jamais persisté côté client en V1 streaming).
type ContentInfo struct {
Path string
Name string
MimeType string
Size int64
}
// OpenContent resolves the physical file of a visible resource. Auth is
// viewer+ (GetFileVisible, own or shared) ; the bytes live under the OWNER
// dir (UPLOAD_DIR/<owner_id>/<resource_id>.<ext>), never under the requester.
// No physical file (metadata-only outbox resource, never uploaded) →
// repository.ErrNotFound (handler maps to 404 NOT_FOUND, same as invisible).
func (s *Resources) OpenContent(userID, resourceID string) (ContentInfo, error) {
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return ContentInfo{}, err
}
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return ContentInfo{}, err
}
if !idPattern.MatchString(ownerID) || !idPattern.MatchString(resourceID) {
return ContentInfo{}, repository.ErrNotFound
}
base, err := filepath.EvalSymlinks(s.UploadDir)
if err != nil {
return ContentInfo{}, repository.ErrNotFound
}
matches, err := filepath.Glob(filepath.Join(s.UploadDir, ownerID, resourceID+".*"))
if err != nil {
return ContentInfo{}, repository.ErrNotFound
}
for _, m := range matches {
if !strings.HasPrefix(filepath.Base(m), resourceID+".") {
continue
}
fi, err := os.Lstat(m)
if err != nil || !fi.Mode().IsRegular() {
continue
}
resolved, err := filepath.EvalSymlinks(m)
if err != nil {
continue
}
rel, err := filepath.Rel(base, resolved)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
mime := row.MimeType
if mime == "" {
mime = "application/octet-stream"
}
// 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 // GetFileOcr returns the OCR text of a file the user can see (viewer+, own or
// shared). Absent text → Text empty ("") with 200 (the caller decides). // shared). Absent text → Text empty ("") with 200 (the caller decides).
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) { func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
@@ -159,10 +237,6 @@ func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
}, nil }, nil
} }
func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
return s.Repo.DeleteFile(ownerID, id)
}
func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) { func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) {
rows, err := s.Repo.ListRootFoldersVisible(ownerID) rows, err := s.Repo.ListRootFoldersVisible(ownerID)
if err != nil { if err != nil {
@@ -175,8 +249,8 @@ func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) {
return folders, nil return folders, nil
} }
func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDTO, int, error) { func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int, facets repository.SearchFacets) ([]FileDTO, int, error) {
rows, total, err := s.Repo.SearchFilesVisible(ownerID, q, pageSize, (page-1)*pageSize) rows, total, err := s.Repo.SearchDocumentsVisible(ownerID, q, facets, pageSize, (page-1)*pageSize)
if err != nil { if err != nil {
return nil, 0, err return nil, 0, err
} }
@@ -206,11 +280,17 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
return FileDTO{}, ErrInvalidUpload return FileDTO{}, ErrInvalidUpload
} }
targetExisting := resourceID != "" targetExisting := resourceID != ""
var cur repository.FileRow
if targetExisting { if targetExisting {
if !idPattern.MatchString(resourceID) { if !idPattern.MatchString(resourceID) {
return FileDTO{}, repository.ErrNotFound return FileDTO{}, repository.ErrNotFound
} }
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil { var err error
// GetFile ne voit que le live : un upload vers une ressource
// trashée/absente/d'autrui → NOT_FOUND (jamais de résurrection
// d'octets sur une ligne en corbeille).
cur, err = s.Repo.GetFile(ownerID, resourceID)
if err != nil {
return FileDTO{}, err return FileDTO{}, err
} }
} else { } else {
@@ -253,10 +333,45 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
} }
} }
// V3 versions : sur upload ciblé, figer l'ancienne génération AVANT
// l'écriture (le rename atomique de copyMultipartAtomic détruirait
// l'ancien contenu). Staging = copie, jamais move : l'échec reste safe.
// Metadata-only (aucun octet live) → rien à versionner.
var staged, stagedExt string
var stagedSize int64
var stagedMime string
var hasStaged bool
if targetExisting {
var ferr error
staged, stagedExt, stagedSize, stagedMime, hasStaged, ferr = s.freezeLive(ownerID, resourceID, cur, destDir)
if ferr != nil {
return FileDTO{}, ferr
}
} else {
// V3 S6 A2 : garde-fou quota sur les créations (les overwrites
// ciblées remplacent des octets existants — gain net ~nul, pas de
// check). Vérifié au header (rejet rapide) PUIS aux octets réels
// (vérité, le header peut mentir, cf. A2).
if err := s.checkQuotaFor(ownerID, file.Size); err != nil {
return FileDTO{}, err
}
}
written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize) written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
if err != nil { if err != nil {
if hasStaged {
_ = os.Remove(staged)
}
return FileDTO{}, err return FileDTO{}, err
} }
if !targetExisting {
// Vérité aux octets réels (le header `file.Size` peut mentir) :
// dépassement → fichier supprimé + 413 (pas d'orphelin).
if err := s.checkQuotaFor(ownerID, written); err != nil {
_ = os.Remove(destPath)
return FileDTO{}, err
}
}
mimeType := sanitizeMimeType(file.Header.Get("Content-Type")) mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
var extPtr *string var extPtr *string
@@ -267,6 +382,10 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr) err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
} else { } else {
err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr) 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 { if err != nil {
// Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique. // Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique.
@@ -280,6 +399,9 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
if !stillOld { if !stillOld {
_ = os.Remove(destPath) _ = os.Remove(destPath)
} }
if hasStaged {
_ = os.Remove(staged)
}
return FileDTO{}, err return FileDTO{}, err
} }
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6). // Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
@@ -288,6 +410,15 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
_ = os.Remove(m) _ = os.Remove(m)
} }
} }
// Overwrite ciblée : l'ancien live devient une version figée (N=3).
// Best-effort après succès des métadonnées : un échec ici ne fait pas
// échouer l'upload (loggé, staging nettoyé).
if hasStaged {
if ferr := s.finalizeVersion(ownerID, resourceID, staged, stagedExt, stagedSize, stagedMime); ferr != nil {
log.Printf("upload: finalize version(%s): %v", resourceID, ferr)
_ = os.Remove(staged)
}
}
row, err := s.Repo.GetFile(ownerID, resourceID) row, err := s.Repo.GetFile(ownerID, resourceID)
if err != nil { if err != nil {
@@ -301,6 +432,9 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
} }
return FileDTO{}, err return FileDTO{}, err
} }
// V3 S5 : octets frais → hash (doublons) + réconciliation des liens.
// Best-effort (jamais d'échec sur du hashing).
s.refreshContentHash(ownerID, resourceID)
return toFileDTO(row), nil return toFileDTO(row), nil
} }
@@ -362,12 +496,58 @@ func copyMultipartAtomic(file *multipart.FileHeader, destDir, destPath string, m
func toFileDTO(row repository.FileRow) FileDTO { func toFileDTO(row repository.FileRow) FileDTO {
return FileDTO{ return FileDTO{
ID: row.ID, ID: row.ID,
Name: row.Name, Name: row.Name,
Size: row.Size, Size: row.Size,
MimeType: row.MimeType, MimeType: row.MimeType,
FolderID: row.FolderID, FolderID: row.FolderID,
CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339), HasContent: row.HasContent,
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339), CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
} }
} }
// UsageDTO serializes GET /users/me/usage (V3 S6 A2) : quota + empreinte,
// dont la corbeille (octets récupérables à la purge).
type UsageDTO struct {
UsedBytes int64 `json:"usedBytes"`
QuotaBytes int64 `json:"quotaBytes"`
FileCount int `json:"fileCount"`
TrashCount int `json:"trashCount"`
TrashedBytes int64 `json:"trashedBytes"`
}
// Usage returns the account footprint (computed, never stored).
func (s *Resources) Usage(ownerID string) (UsageDTO, error) {
user, err := s.Repository.Users.GetByID(ownerID)
if err != nil {
return UsageDTO{}, err
}
usage, err := s.Repo.StorageUsage(ownerID)
if err != nil {
return UsageDTO{}, err
}
return UsageDTO{
UsedBytes: usage.UsedBytes, QuotaBytes: user.QuotaBytes,
FileCount: usage.FileCount, TrashCount: usage.TrashCount,
TrashedBytes: usage.TrashedBytes,
}, nil
}
// checkQuotaFor rejects a creation of incoming bytes that would overflow the
// account quota (V3 S6 A2). Compte absent → l'erreur remonte (jamais de
// défaut silencieux qui laisserait passer).
func (s *Resources) checkQuotaFor(ownerID string, incoming int64) error {
user, err := s.Repository.Users.GetByID(ownerID)
if err != nil {
return err
}
usage, err := s.Repo.StorageUsage(ownerID)
if err != nil {
return err
}
if usage.UsedBytes+incoming > user.QuotaBytes {
return ErrQuotaExceeded
}
return nil
}
+17 -5
View File
@@ -291,12 +291,24 @@ func TestUploadReuploadNewExtensionRemovesStaleFile(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("readdir: %v", err) t.Fatalf("readdir: %v", err)
} }
if len(entries) != 1 || entries[0].Name() != resourceID+".jpg" { // V3 versions : le re-upload fige l'ancien live (png) en version, le
names := make([]string, 0, len(entries)) // cleanup des suffixes orphelins ne touche que le live. Attendu : le
for _, e := range entries { // live `<id>.jpg` + un dossier `.versions/` contenant le png figé.
names = append(names, e.Name()) var live []string
for _, e := range entries {
if e.Name() == ".versions" {
continue
} }
t.Errorf("un seul physique attendu (%s.jpg), got %v", resourceID, names) live = append(live, e.Name())
}
if len(live) != 1 || live[0] != resourceID+".jpg" {
t.Errorf("un seul live attendu (%s.jpg), got %v", resourceID, live)
}
verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", resourceID+"_v*"))
if len(verFiles) != 1 {
t.Errorf("une version figée (png) attendue, got %v", verFiles)
} else if content, err := os.ReadFile(verFiles[0]); err != nil || string(content) != "PNGDATA" {
t.Errorf("version figée = %q, err=%v (attendu PNGDATA)", content, err)
} }
content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg")) content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg"))
if err != nil || string(content) != "JPGDATA!" { if err != nil || string(content) != "JPGDATA!" {
+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
}
+256 -41
View File
@@ -23,6 +23,16 @@ const (
OpUpdateShare = "update_share" OpUpdateShare = "update_share"
OpCreateLink = "create_link" OpCreateLink = "create_link"
OpRevokeLink = "revoke_link" OpRevokeLink = "revoke_link"
// V2 placements : un device signale la présence de ses octets.
OpReportBytes = "report_bytes"
// V3 corbeille (P1) : trash = soft (restaure via restore), purge = hard.
// delete_resource (legacy) est mappé vers trash_resource (même sémantique
// d'idempotence, cf. applyTrashOp).
OpTrashResource = "trash_resource"
OpRestoreResource = "restore_resource"
OpPurgeResource = "purge_resource"
// V3 corrections (S3) : remplace le jeu `user` des faits (editor+).
OpCorrectFacts = "correct_facts"
) )
// SyncOperation is one outbox entry (shadow of mobile PendingOperationRow). // SyncOperation is one outbox entry (shadow of mobile PendingOperationRow).
@@ -43,10 +53,22 @@ type FailedOperation struct {
Message string `json:"message"` Message string `json:"message"`
} }
// SyncResult is the outbox response: applied = index of the next op to send. // ConflictInfo reports a last-writer-wins rename applied over a concurrent
// change (V3 S6 A4). Non-fatal : le batch continue, le client affiche
// « renommé ailleurs » avec le nom serveur gagnant.
type ConflictInfo struct {
OperationID string `json:"operation_id"`
ResourceID string `json:"resource_id"`
ServerName string `json:"serverName"`
ServerUpdatedAt int64 `json:"serverUpdatedAt"`
}
// SyncResult is the outbox response: applied = index of the next op to send,
// conflicts = renames concurrents appliqués quand même (non-fataux, S6 A4).
type SyncResult struct { type SyncResult struct {
Applied int `json:"applied"` Applied int `json:"applied"`
Failed *FailedOperation `json:"failed,omitempty"` Failed *FailedOperation `json:"failed,omitempty"`
Conflicts []ConflictInfo `json:"conflicts,omitempty"`
} }
type createResourcePayload struct { type createResourcePayload struct {
@@ -54,10 +76,18 @@ type createResourcePayload struct {
ParentResourceID string `json:"parentResourceId"` // dossier parent (racine si vide), cf. docs/api-v1.md §6.1 ParentResourceID string `json:"parentResourceId"` // dossier parent (racine si vide), cf. docs/api-v1.md §6.1
MimeType string `json:"mimeType"` MimeType string `json:"mimeType"`
Extension string `json:"extension"` Extension string `json:"extension"`
// V3 S5 : session de scan opaque (32-hex mobile) — le serveur en déduit
// les arêtes same_scan. Absent = ressource isolée (jamais d'erreur).
ScanSessionID string `json:"scanSessionId"`
} }
type renamePayload struct { type renamePayload struct {
Name string `json:"name"` Name string `json:"name"`
// V3 S6 A4 : `updated_at` (ms epoch) vu par le client au moment du
// rename. Si la ressource a bougé depuis (concurrent), le rename
// s'applique quand même (last-writer-wins) mais est signalé en
// `conflicts` (transparence, pas de CRDT).
BaseUpdatedAt *int64 `json:"baseUpdatedAt"`
} }
type movePayload struct { type movePayload struct {
@@ -65,10 +95,11 @@ type movePayload struct {
} }
type sharePayload struct { type sharePayload struct {
GranteeUserID string `json:"granteeUserId"` GranteeUserID string `json:"granteeUserId"`
Access string `json:"access"` GranteeGroupID string `json:"granteeGroupId"`
Inherit *bool `json:"inherit"` Access string `json:"access"`
ExpiresAt *int64 `json:"expiresAt"` Inherit *bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
} }
type revokeSharePayload struct { type revokeSharePayload struct {
@@ -85,6 +116,14 @@ type revokeLinkPayload struct {
Token string `json:"token"` Token string `json:"token"`
} }
type reportBytesPayload struct {
HasBytes *bool `json:"hasBytes"`
}
type correctFactsPayload struct {
Facts []FactDTO `json:"facts"`
}
func classifySyncError(err error) (string, string) { func classifySyncError(err error) (string, string) {
switch { switch {
case errors.Is(err, repository.ErrNameConflict): case errors.Is(err, repository.ErrNameConflict):
@@ -93,6 +132,8 @@ func classifySyncError(err error) (string, string) {
return "NOT_FOUND", "target resource or folder not found" return "NOT_FOUND", "target resource or folder not found"
case errors.Is(err, repository.ErrGranteeNotFound): case errors.Is(err, repository.ErrGranteeNotFound):
return "GRANTEE_NOT_FOUND", "the specified user does not exist" return "GRANTEE_NOT_FOUND", "the specified user does not exist"
case errors.Is(err, repository.ErrGroupNotFound):
return "GROUP_NOT_FOUND", "the specified group does not exist"
case errors.Is(err, repository.ErrPayloadMismatch): case errors.Is(err, repository.ErrPayloadMismatch):
return "INVALID_REQUEST", "operation replayed with different payload" return "INVALID_REQUEST", "operation replayed with different payload"
case errors.Is(err, errCycle): case errors.Is(err, errCycle):
@@ -132,33 +173,39 @@ var errCycle = errors.New("cannot move a resource into its own subtree")
// explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client // explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client
// sait exactement où reprendre. // sait exactement où reprendre.
func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) { func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) {
// Conflits de rename (S6 A4) : non-fataux, collectés tout au long du
// batch et renvoyés avec le résultat (le batch continue).
var conflicts []ConflictInfo
fail := func(i int, op *SyncOperation, code, message string) (SyncResult, error) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}, Conflicts: conflicts}, nil
}
for i := range ops { for i := range ops {
op := &ops[i] op := &ops[i]
if err := validateSyncOp(op); err != nil { if err := validateSyncOp(op); err != nil {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil return fail(i, op, "INVALID_REQUEST", err.Error())
} }
claimed, err := s.Repository.Operations.Claim(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload) claimed, err := s.Repository.Operations.Claim(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload)
if err != nil { if err != nil {
// Faute client (clé ou payload malformé) → INVALID_REQUEST halt, // Faute client (clé ou payload malformé) → INVALID_REQUEST halt,
// message statique sûr ; panne persistance → INTERNAL explicite. // message statique sûr ; panne persistance → INTERNAL explicite.
if errors.Is(err, repository.ErrInvalidOperationID) { 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 return fail(i, op, "INVALID_REQUEST", "operation_id must be 32 lowercase hex chars")
} }
if errors.Is(err, repository.ErrInvalidPayload) { if errors.Is(err, repository.ErrInvalidPayload) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil return fail(i, op, "INVALID_REQUEST", "invalid payload JSON")
} }
log.Printf("sync: claim device=%s op=%s: %v", deviceID, op.OperationID, err) 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 return fail(i, op, "INTERNAL", "failed to persist operation state")
} }
if !claimed { if !claimed {
// Rejeu : même (device, op) déjà tracé — comparer (A9). // Rejeu : même (device, op) déjà tracé — comparer (A9).
stored, err := s.Repository.Operations.Get(deviceID, op.OperationID) stored, err := s.Repository.Operations.Get(deviceID, op.OperationID)
if err != nil { if err != nil {
log.Printf("sync: replay read device=%s op=%s: %v", deviceID, op.OperationID, err) 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 return fail(i, op, "INTERNAL", "failed to read operation state")
} }
if err := stored.MatchesReplay(op.Operation, derefString(op.ResourceID), op.Payload); err != 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 return fail(i, op, "INVALID_REQUEST", "operation replayed with different payload")
} }
if stored.Status == repository.OpStatusApplied { if stored.Status == repository.OpStatusApplied {
continue // déjà appliquée à l'identique → skip idempotent continue // déjà appliquée à l'identique → skip idempotent
@@ -166,16 +213,18 @@ func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (Sy
// Trace 'failed' à payload identique : la première tentative est // Trace 'failed' à payload identique : la première tentative est
// morte avant MarkApplied (crash) → on ré-applique (recovery). // morte avant MarkApplied (crash) → on ré-applique (recovery).
} }
if err := s.applySyncOp(userID, op); err != nil { if conflict, err := s.applySyncOpWithConflict(userID, deviceID, op); err != nil {
code, message := classifySyncError(err) code, message := classifySyncError(err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil return fail(i, op, code, message)
} else if conflict != nil {
conflicts = append(conflicts, *conflict)
} }
if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil { if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil {
log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err) log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "operation applied but trace update failed; safe to retry"}}, nil return fail(i, op, "INTERNAL", "operation applied but trace update failed; safe to retry")
} }
} }
return SyncResult{Applied: len(ops)}, nil return SyncResult{Applied: len(ops), Conflicts: conflicts}, nil
} }
func validateSyncOp(op *SyncOperation) error { func validateSyncOp(op *SyncOperation) error {
@@ -190,7 +239,9 @@ func validateSyncOp(op *SyncOperation) error {
} }
switch op.Operation { switch op.Operation {
case OpCreateResource, OpUpdateMetadata, OpMoveResource, OpDeleteResource, case OpCreateResource, OpUpdateMetadata, OpMoveResource, OpDeleteResource,
OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink: OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink,
OpReportBytes, OpTrashResource, OpRestoreResource, OpPurgeResource,
OpCorrectFacts:
default: default:
return errors.New("unknown operation " + op.Operation) return errors.New("unknown operation " + op.Operation)
} }
@@ -200,7 +251,49 @@ func validateSyncOp(op *SyncOperation) error {
return nil return nil
} }
func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error { // conflictToleranceMs absorbe le skew d'horloge client/serveur ET la
// troncation à la seconde des `updatedAt` RFC3339 lus par le client : un
// écart ≤ 2 s n'est pas un conflit (ex. create suivi d'un rename immédiat
// par le même device). Au-delà, quelqu'un d'autre a écrit entre-temps.
const conflictToleranceMs = 2000
// applySyncOpWithConflict applique une op et détecte les renames concurrents
// (S6 A4) : si `baseUpdatedAt` est fourni et que la ressource a bougé depuis
// (au-delà de la tolérance), le rename s'applique quand même (LWW) mais est
// signalé. Sans base (vieux clients) : aucun signalement, comportement V1.
func (s *Resources) applySyncOpWithConflict(ownerID, deviceID string, op *SyncOperation) (*ConflictInfo, error) {
var base *int64
resID := derefString(op.ResourceID)
if op.Operation == OpUpdateMetadata {
var p renamePayload
if err := json.Unmarshal(op.Payload, &p); err == nil && p.BaseUpdatedAt != nil {
base = p.BaseUpdatedAt
}
}
var preMs int64
havePre := false
if base != nil {
if _, ms, err := s.Repo.LiveNameAndUpdatedAt(resID); err == nil {
preMs, havePre = ms, true
}
}
if err := s.applySyncOp(ownerID, deviceID, op); err != nil {
return nil, err
}
if base != nil && havePre && preMs > *base+conflictToleranceMs {
name, ms, err := s.Repo.LiveNameAndUpdatedAt(resID)
if err != nil {
return nil, nil // renommé puis supprimé dans le même batch : rien à signaler.
}
return &ConflictInfo{
OperationID: op.OperationID, ResourceID: resID,
ServerName: name, ServerUpdatedAt: ms,
}, nil
}
return nil, nil
}
func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) error {
resourceID := derefString(op.ResourceID) resourceID := derefString(op.ResourceID)
switch op.Operation { switch op.Operation {
case OpCreateResource: case OpCreateResource:
@@ -218,6 +311,11 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
if p.Name == "" { if p.Name == "" {
return errors.New("payload.name required") return errors.New("payload.name required")
} }
// V3 S5 : session de scan opaque (dérive same_scan, jamais d'erreur
// bloquante au-delà du format).
if p.ScanSessionID != "" && !resourceIDPattern.MatchString(p.ScanSessionID) {
return errors.New("payload.scanSessionId must be 32 lowercase hex chars")
}
// Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon, // Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon,
// cohérent avec move_resource). Ordre du SAF walk : parent avant enfant. // cohérent avec move_resource). Ordre du SAF walk : parent avant enfant.
if p.ParentResourceID != "" { if p.ParentResourceID != "" {
@@ -247,6 +345,15 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
} }
return insertErr return insertErr
} }
// V3 S5 : session de scan → arêtes same_scan (best-effort, jamais
// bloquant : la ressource existe, seuls les liens manqueraient).
if p.ScanSessionID != "" {
if err := s.Repo.SetScanSession(ownerID, resourceID, p.ScanSessionID); err != nil {
log.Printf("sync: scan session %s: %v", resourceID, err)
} else if err := s.Repo.ReconcileLinks(ownerID, resourceID); err != nil {
log.Printf("sync: reconcile %s: %v", resourceID, err)
}
}
return nil return nil
case OpUpdateMetadata: case OpUpdateMetadata:
@@ -272,10 +379,10 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
return errors.New("payload.name required") return errors.New("payload.name required")
} }
// NOTE : UpdateNameByID (non-scopé) est volontaire ici — un editor // NOTE : UpdateNameByID (non-scopé) est volontaire ici — un editor
// non-owner peut renommer (EffectiveAccess vérifié plus haut), donc // non-owner peut renommer (EffectiveAccess vérifié plus haut), donc
// UpdateNameOwned(ownerID, ...) rejetterait à tort. La garde // UpdateNameOwned(ownerID, ...) rejetterait à tort. La garde
// d'autorisation précède immédiatement l'écriture. // d'autorisation précède immédiatement l'écriture.
return s.Repo.UpdateNameByID(resourceID, p.Name) return s.Repo.UpdateNameByID(resourceID, p.Name)
case OpMoveResource: case OpMoveResource:
// A8 : move owner-only. Source non-owned (absente OU d'autrui) → // A8 : move owner-only. Source non-owned (absente OU d'autrui) →
@@ -301,11 +408,13 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
} }
return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID) return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID)
case OpDeleteResource: case OpDeleteResource, OpTrashResource:
// A8 : delete owner-only. Ligne vivante d'autrui → NOT_FOUND halt // V3 : delete_resource (legacy) = trash_resource. A8 : owner-only.
// (pas de applied silencieux). Aucune ligne vivante (jamais existé, // Ligne vivante d'autrui → NOT_FOUND halt (pas de applied
// ou déjà supprimée par son owner) → no-op idempotent : l'état // silencieux). Aucune ligne (jamais existé, déjà trashée/purgée par
// terminal (absente) est déjà atteint, le rejeu reste sûr. // son owner) → no-op idempotent : l'état terminal est atteint.
// Note : une ressource déjà trashée reste trashée (re-trash = no-op
// via TrashResource qui ne touche que deleted_at IS NULL).
exists, err := s.Repo.ExistsOwner(ownerID, resourceID) exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil { if err != nil {
return err return err
@@ -319,7 +428,53 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
} }
return repository.ErrNotFound return repository.ErrNotFound
} }
return s.Repo.SyncDelete(ownerID, resourceID) return s.Repo.TrashResource(ownerID, resourceID)
case OpRestoreResource:
// Owner-only (live ou trashé). Absente → no-op (rien à restaurer,
// l'état terminal — visible — ne peut pas être atteint autrement,
// mais halter casserait la convergence d'un restore rejoué après
// purge... non : après purge la ligne n'existe plus, le restore est
// sans objet → no-op documenté). Vivante d'autrui → NOT_FOUND halt.
owned, err := s.Repo.ExistsOwnerAny(ownerID, resourceID)
if err != nil {
return err
}
if !owned {
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil
}
return err
}
return repository.ErrNotFound
}
return s.Repo.RestoreResource(ownerID, resourceID)
case OpPurgeResource:
// Owner-only (live ou trashé). Absente → no-op idempotent.
// Vivante d'autrui → NOT_FOUND halt. Octets supprimés best-effort.
owned, err := s.Repo.ExistsOwnerAny(ownerID, resourceID)
if err != nil {
return err
}
if !owned {
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil
}
return err
}
return repository.ErrNotFound
}
purged, err := s.Repo.PurgeResource(ownerID, resourceID)
if err != nil {
return err
}
for _, pid := range purged {
s.removePhysical(ownerID, pid)
}
return nil
case OpShare, OpUpdateShare: case OpShare, OpUpdateShare:
return s.applyShareOp(ownerID, resourceID, op) return s.applyShareOp(ownerID, resourceID, op)
@@ -333,11 +488,52 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
case OpRevokeLink: case OpRevokeLink:
return s.applyRevokeLinkOp(ownerID, resourceID, op) return s.applyRevokeLinkOp(ownerID, resourceID, op)
case OpReportBytes:
return s.applyReportBytesOp(ownerID, deviceID, resourceID, op)
case OpCorrectFacts:
// S3 : même garde que CorrectFacts (editor+, A8) — une ressource
// visible sans droit de mutation n'est pas corrigeable (NOT_FOUND,
// pas d'oracle). Le payload porte le jeu `user` complet
// (full-replace, jamais de diff).
var p correctFactsPayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
for i, f := range p.Facts {
if _, err := validateFactParam(i, f); err != nil {
return err
}
}
return s.CorrectFacts(ownerID, resourceID, p.Facts)
default: default:
return errors.New("unknown operation " + op.Operation) 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. // applyShareOp handles OpShare and OpUpdateShare: upsert a user-to-user grant.
func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) error { func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) error {
exists, err := s.Repo.ExistsOwner(ownerID, resourceID) exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
@@ -351,23 +547,22 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
if err := json.Unmarshal(op.Payload, &p); err != nil { if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error()) return errors.New("invalid payload: " + err.Error())
} }
if p.GranteeUserID == "" { // Cible : exactement un principal (user XOR groupe, V2-6).
return errors.New("payload.granteeUserId required") 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") 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) rank := repository.AccessFromString(p.Access)
if rank < repository.AccessViewer || rank > repository.AccessEditor { if rank < repository.AccessViewer || rank > repository.AccessEditor {
return errors.New("payload.access must be viewer, commenter, or editor") 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 inherit := true
if p.Inherit != nil { if p.Inherit != nil {
inherit = *p.Inherit inherit = *p.Inherit
@@ -380,8 +575,28 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
} }
expiresAt = &t expiresAt = &t
} }
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil { if isUser {
return err // 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. // Bump resource updated_at so the grantee's delta snapshot picks it up.
// Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le // Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le
+83
View File
@@ -0,0 +1,83 @@
package service
import (
"testing"
"github.com/kazier/backend/repository"
)
// TestRenameConflictReporting : un rename avec baseUpdatedAt périmée
// s'applique quand même (LWW) mais est signalé en conflicts[] (S6 A4) ;
// avec une base fraîche, aucun signalement.
func TestRenameConflictReporting(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "conflict-user")
deviceA := mustRegisterDevice(t, s.Repository, "c0000000000000000000000000000001")
fileID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, fileID, "origine.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
// Base fraîche : pas de conflit.
name, ms, err := s.Repository.Resources.LiveNameAndUpdatedAt(fileID)
if err != nil || name != "origine.txt" {
t.Fatalf("live: %q %d %v", name, ms, err)
}
res, err := s.ApplyBatch(userID, deviceA, []SyncOperation{
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{
"name": "v2.txt", "baseUpdatedAt": ms,
}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Applied != 1 || res.Failed != nil || len(res.Conflicts) != 0 {
t.Fatalf("rename frais doit être silencieux: %+v", res)
}
// Base périmée (concurrent théorique entre-temps) : appliqué + signalé.
stale := ms - 60_000
res, err = s.ApplyBatch(userID, deviceA, []SyncOperation{
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{
"name": "v3.txt", "baseUpdatedAt": stale,
}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Applied != 1 || res.Failed != nil {
t.Fatalf("rename concurrent doit s'appliquer (LWW): %+v", res)
}
if len(res.Conflicts) != 1 {
t.Fatalf("conflit manquant: %+v", res)
}
c := res.Conflicts[0]
if c.ResourceID != fileID || c.ServerName != "v3.txt" || c.ServerUpdatedAt <= 0 {
t.Fatalf("conflit inattendu: %+v", c)
}
// Sans base (vieux client) : appliqué, jamais signalé.
res, err = s.ApplyBatch(userID, deviceA, []SyncOperation{
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "v4.txt"}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Applied != 1 || res.Failed != nil || len(res.Conflicts) != 0 {
t.Fatalf("sans base : silencieux: %+v", res)
}
// Tolérance 2 s : un écart d'1 s (skew/troncation) n'est pas un conflit.
_, nowMs, _ := s.Repository.Resources.LiveNameAndUpdatedAt(fileID)
res, err = s.ApplyBatch(userID, deviceA, []SyncOperation{
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{
"name": "v5.txt", "baseUpdatedAt": nowMs - 1000,
}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if len(res.Conflicts) != 0 {
t.Fatalf("écart 1 s ne doit pas signaler: %+v", res)
}
}
+73
View File
@@ -1485,3 +1485,76 @@ func TestDeleteAbsentIsIdempotentNoop(t *testing.T) {
t.Errorf("delete absent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err) 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)
}
}
+420
View File
@@ -0,0 +1,420 @@
package service
import (
"fmt"
"io"
"log"
"os"
"path/filepath"
"strings"
"time"
"github.com/kazier/backend/repository"
)
// TrashRetention is the corbeille lifetime (V3 P1 : 30j, cf. V3.md §2).
// Après ce délai, la passe de purge détruit définitivement les lignes.
const TrashRetention = 30 * 24 * time.Hour
// TrashDTO serializes one trashed resource for GET /trash.
type TrashDTO struct {
ID string `json:"id"`
Type string `json:"type"`
Name string `json:"name"`
Size int64 `json:"size"`
TrashedAt string `json:"trashedAt"`
UpdatedAt string `json:"updatedAt,omitempty"`
}
// VersionDTO serializes one frozen byte-generation for GET /files/:id/versions.
type VersionDTO struct {
VersionNo int `json:"versionNo"`
Size int64 `json:"size"`
MimeType string `json:"mimeType,omitempty"`
CreatedAt string `json:"createdAt"`
}
// Trash soft-deletes a resource and its subtree (corbeille). Owner-only :
// foreign or absent → repository.ErrNotFound (même code, pas d'oracle).
// delete_resource (legacy) est mappé vers Trash (cf. applySyncOp).
func (s *Resources) Trash(ownerID, id string) (string, error) {
owned, err := s.Repo.ExistsOwner(ownerID, id)
if err != nil {
return "", err
}
if !owned {
return "", repository.ErrNotFound
}
if err := s.Repo.TrashResource(ownerID, id); err != nil {
return "", err
}
return id, nil
}
// DeleteFile is the legacy owner-only file removal — now a trash (V3 P1).
// Purge définitive : Purge. Le handler choisit via ?mode=purge.
func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
// Restreint aux files comme avant (les dossiers passent par l'outbox).
if _, err := s.Repo.GetFile(ownerID, id); err != nil {
return "", err
}
return s.Trash(ownerID, id)
}
// Restore clears the trash flag on a resource, its subtree and its ancestor
// chain. Owner-only : absent/foreign → ErrNotFound ; live → no-op succès.
func (s *Resources) Restore(ownerID, id string) (string, error) {
owned, err := s.Repo.ExistsOwnerAny(ownerID, id)
if err != nil {
return "", err
}
if !owned {
return "", repository.ErrNotFound
}
if err := s.Repo.RestoreResource(ownerID, id); err != nil {
return "", err
}
return id, nil
}
// Purge hard-deletes a resource and its subtree (lignes + versions + octets).
// Owner-only (trashed ou live) : absent/foreign → ErrNotFound.
// Les fichiers physiques sont supprimés best-effort (jamais d'échec sur FS).
func (s *Resources) Purge(ownerID, id string) (string, error) {
owned, err := s.Repo.ExistsOwnerAny(ownerID, id)
if err != nil {
return "", err
}
if !owned {
return "", repository.ErrNotFound
}
purged, err := s.Repo.PurgeResource(ownerID, id)
if err != nil {
return "", err
}
for _, pid := range purged {
s.removePhysical(ownerID, pid)
}
return id, nil
}
// ListTrashed returns the owner's corbeille, most recently trashed first.
func (s *Resources) ListTrashed(ownerID string, page, pageSize int) ([]TrashDTO, int, error) {
rows, total, err := s.Repo.ListTrashed(ownerID, pageSize, (page-1)*pageSize)
if err != nil {
return nil, 0, err
}
out := make([]TrashDTO, 0, len(rows))
for _, row := range rows {
out = append(out, TrashDTO{
ID: row.ID,
Type: row.Type,
Name: row.Name,
Size: row.Size,
TrashedAt: row.TrashedAt.UTC().Format(time.RFC3339),
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
})
}
return out, total, nil
}
// ListVersions returns the frozen byte-generations of a live owned resource,
// newest first. Trashed/absent/foreign → ErrNotFound.
func (s *Resources) ListVersions(ownerID, id string) ([]VersionDTO, error) {
rows, err := s.Repo.ListVersions(ownerID, id)
if err != nil {
return nil, err
}
out := make([]VersionDTO, 0, len(rows))
for _, row := range rows {
out = append(out, VersionDTO{
VersionNo: row.VersionNo,
Size: row.Size,
MimeType: row.MimeType,
CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
})
}
return out, nil
}
// RestoreVersion recopies la génération n vers l'emplacement live (l'actuel
// est à son tour versionné, puis élagué à N=3). Owner-only, parent live.
func (s *Resources) RestoreVersion(ownerID, id string, n int) (FileDTO, error) {
ver, err := s.Repo.GetVersion(ownerID, id, n)
if err != nil {
return FileDTO{}, err
}
srcAbs := filepath.Join(s.UploadDir, ver.StoredPath)
if fi, err := os.Stat(srcAbs); err != nil || !fi.Mode().IsRegular() {
return FileDTO{}, repository.ErrNotFound
}
cur, err := s.Repo.GetFile(ownerID, id)
if err != nil {
return FileDTO{}, err
}
destDir := filepath.Join(s.UploadDir, ownerID)
if err := os.MkdirAll(destDir, 0o700); err != nil {
return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
}
if err := os.Chmod(destDir, 0o700); err != nil {
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
}
// 1. Geler l'actuel (staging copy, pas de move — l'échec reste safe).
staged, stagedExt, stagedSize, stagedMime, hasLive, err := s.freezeLive(ownerID, id, cur, destDir)
if err != nil {
return FileDTO{}, err
}
if hasLive {
defer func() {
// Staging orphelin si on sort en erreur avant finalize.
if err != nil {
_ = os.Remove(staged)
}
}()
}
// 2. Recopier la version vers le live (même atomicité que l'upload).
destName := id
if ver.Extension != "" {
destName = id + "." + ver.Extension
}
if err := copyFileAtomic(srcAbs, destDir, filepath.Join(destDir, destName)); err != nil {
return FileDTO{}, err
}
mime := ver.MimeType
if mime == "" {
mime = "application/octet-stream"
}
var extPtr *string
if ver.Extension != "" {
extPtr = &ver.Extension
}
fi, err := os.Stat(filepath.Join(destDir, destName))
if err != nil {
return FileDTO{}, err
}
if err := s.Repo.UpdatePhysical(ownerID, id, fi.Size(), &mime, extPtr); err != nil {
return FileDTO{}, err
}
if err := s.Repo.SetHasContent(ownerID, id, true); err != nil {
log.Printf("versions: SetHasContent(%s): %v", id, err)
}
// 3. Nettoyer les suffixes orphelins + figer l'ancien actuel en version.
s.removeStaleSuffixes(destDir, id, destName)
if hasLive {
if ferr := s.finalizeVersion(ownerID, id, staged, stagedExt, stagedSize, stagedMime); ferr != nil {
log.Printf("versions: finalize displaced current(%s): %v", id, ferr)
}
}
row, err := s.Repo.GetFile(ownerID, id)
if err != nil {
return FileDTO{}, err
}
return toFileDTO(row), nil
}
// PurgeExpiredTrash détruit les lignes trashées depuis plus de retention
// (corbeille 30j) + leurs octets (best-effort). Boucle par batch jusqu'à vide.
// Retourne le nombre de ressources racines purgées. Appelé au boot puis par
// ticker (cf. cmd/server/main.go).
func (s *Resources) PurgeExpiredTrash(retention time.Duration) (int, error) {
cutoff := time.Now().Add(-retention)
total := 0
for {
purged, err := s.Repo.PurgeExpiredTrash(cutoff, 500)
if err != nil {
return total, err
}
if len(purged) == 0 {
return total, nil
}
for _, p := range purged {
s.removePhysical(p.UserID, p.ResourceID)
total++
}
}
}
// removePhysical supprime tous les octets connus d'une ressource : live
// (UPLOAD_DIR/<user>/<resource>.* + nu) et versions (.versions/). Best-effort.
func (s *Resources) removePhysical(userID, resourceID string) {
if !idPattern.MatchString(userID) || !idPattern.MatchString(resourceID) {
return
}
dir := filepath.Join(s.UploadDir, userID)
matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*"))
for _, m := range matches {
if strings.HasPrefix(filepath.Base(m), resourceID+".") {
_ = os.Remove(m)
}
}
_ = os.Remove(filepath.Join(dir, resourceID))
verMatches, _ := filepath.Glob(filepath.Join(dir, ".versions", resourceID+"_v*"))
for _, m := range verMatches {
_ = os.Remove(m)
}
}
// removeStaleSuffixes supprime les anciens suffixes orphelins après écriture
// du live (même règle que Upload : tout `<id>.*` sauf le live).
func (s *Resources) removeStaleSuffixes(destDir, resourceID, liveName string) {
matches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
for _, m := range matches {
if filepath.Base(m) != liveName && strings.HasPrefix(filepath.Base(m), resourceID+".") {
_ = os.Remove(m)
}
}
}
// livePhysicalFile retourne le chemin live existant d'une ressource (suffixé
// ou nu), "" si metadata-only.
func livePhysicalFile(uploadDir, ownerID, resourceID string) string {
dir := filepath.Join(uploadDir, ownerID)
matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*"))
for _, m := range matches {
if strings.HasPrefix(filepath.Base(m), resourceID+".") {
if fi, err := os.Lstat(m); err == nil && fi.Mode().IsRegular() {
return m
}
}
}
if bare := filepath.Join(dir, resourceID); bare != "" {
if fi, err := os.Lstat(bare); err == nil && fi.Mode().IsRegular() {
return bare
}
}
return ""
}
// freezeLive copie les octets live vers un staging temp (jamais de move :
// l'original reste en place jusqu'au succès). Retourne le staging + métadonnées.
// ok=false quand metadata-only (rien à versionner).
func (s *Resources) freezeLive(ownerID, resourceID string, cur repository.FileRow, destDir string) (staging, ext string, size int64, mime string, ok bool, err error) {
live := livePhysicalFile(s.UploadDir, ownerID, resourceID)
if live == "" {
return "", "", 0, "", false, nil
}
base := filepath.Base(live)
ext = ""
if strings.HasPrefix(base, resourceID+".") {
ext = strings.TrimPrefix(base, resourceID+".")
}
tmp, err := os.CreateTemp(destDir, ".ver-"+resourceID+".*")
if err != nil {
return "", "", 0, "", false, fmt.Errorf("stage version: %w", err)
}
staging = tmp.Name()
if err := copyInto(tmp, live); err != nil {
tmp.Close()
_ = os.Remove(staging)
return "", "", 0, "", false, err
}
if err := tmp.Close(); err != nil {
_ = os.Remove(staging)
return "", "", 0, "", false, fmt.Errorf("stage version: %w", err)
}
fi, err := os.Stat(staging)
if err != nil {
_ = os.Remove(staging)
return "", "", 0, "", false, err
}
mime = cur.MimeType
if mime == "" {
mime = "application/octet-stream"
}
return staging, ext, fi.Size(), mime, true, nil
}
// finalizeVersion déplace le staging vers .versions/, insère la ligne et
// élague au-delà de MaxVersions (fichiers élagués supprimés best-effort).
func (s *Resources) finalizeVersion(ownerID, resourceID, staged, ext string, size int64, mime string) error {
no, err := s.Repo.NextVersionNo(resourceID)
if err != nil {
return err
}
rel := filepath.Join(ownerID, ".versions", fmt.Sprintf("%s_v%d", resourceID, no))
if ext != "" {
rel += "." + ext
}
abs := filepath.Join(s.UploadDir, rel)
if err := os.MkdirAll(filepath.Dir(abs), 0o700); err != nil {
return err
}
if err := os.Rename(staged, abs); err != nil {
return err
}
if err := os.Chmod(abs, 0o600); err != nil {
log.Printf("versions: chmod(%s): %v", rel, err)
}
var extPtr *string
if ext != "" {
extPtr = &ext
}
vid, err := repository.NewIDErr()
if err != nil {
return err
}
if err := s.Repo.InsertVersion(vid, resourceID, no, size, &mime, extPtr, rel); err != nil {
_ = os.Remove(abs)
return err
}
pruned, err := s.Repo.PruneVersions(resourceID, repository.MaxVersions)
if err != nil {
log.Printf("versions: prune(%s): %v", resourceID, err)
return nil
}
for _, p := range pruned {
_ = os.Remove(filepath.Join(s.UploadDir, p))
}
return nil
}
// copyInto copie src vers le fichier ouvert dst.
func copyInto(dst *os.File, src string) error {
in, err := os.Open(src)
if err != nil {
return err
}
defer in.Close()
if _, err := io.Copy(dst, in); err != nil {
return fmt.Errorf("copy version bytes: %w", err)
}
return nil
}
// copyFileAtomic recopie src vers destPath via temp+rename (0600).
func copyFileAtomic(src, destDir, destPath string) error {
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
if err != nil {
return fmt.Errorf("create tmp file: %w", err)
}
tmpName := tmp.Name()
success := false
defer func() {
if !success {
_ = os.Remove(tmpName)
}
}()
if err := tmp.Chmod(0o600); err != nil {
tmp.Close()
return fmt.Errorf("chmod tmp file: %w", err)
}
if err := copyInto(tmp, src); err != nil {
tmp.Close()
return err
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return fmt.Errorf("fsync: %w", err)
}
if err := tmp.Close(); err != nil {
return fmt.Errorf("close: %w", err)
}
if err := os.Rename(tmpName, destPath); err != nil {
return fmt.Errorf("commit: %w", err)
}
if err := os.Chmod(destPath, 0o600); err != nil {
return fmt.Errorf("chmod: %w", err)
}
success = true
return nil
}
+364
View File
@@ -0,0 +1,364 @@
package service
import (
"errors"
"os"
"path/filepath"
"testing"
"time"
"github.com/kazier/backend/repository"
)
func mustInsertFile(t *testing.T, s *Resources, userID, name string) string {
t.Helper()
id := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, id, name, "", 0, nil, nil); err != nil {
t.Fatalf("insert file %q: %v", name, err)
}
return id
}
func TestTrashRestoreRoundtrip(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-roundtrip")
fileID := mustInsertFile(t, s, userID, "acte.pdf")
if _, err := s.Trash(userID, fileID); err != nil {
t.Fatalf("trash: %v", err)
}
if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("GetFile après trash : attendu NOT_FOUND, got %v", err)
}
items, total, err := s.ListTrashed(userID, 1, 50)
if err != nil {
t.Fatalf("list trashed: %v", err)
}
if total != 1 || len(items) != 1 || items[0].ID != fileID {
t.Fatalf("corbeille: total=%d items=%+v", total, items)
}
if _, err := s.Restore(userID, fileID); err != nil {
t.Fatalf("restore: %v", err)
}
if _, err := s.Repo.GetFile(userID, fileID); err != nil {
t.Fatalf("GetFile après restore: %v", err)
}
if _, total, err := s.ListTrashed(userID, 1, 50); err != nil || total != 0 {
t.Fatalf("corbeille après restore: total=%d err=%v", total, err)
}
}
func TestTrashSubtree(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-subtree")
folderID := repository.NewID()
if err := s.Repository.Resources.InsertFolder(userID, folderID, "Dossier", ""); err != nil {
t.Fatalf("insert folder: %v", err)
}
childID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, childID, "enfant.txt", folderID, 0, nil, nil); err != nil {
t.Fatalf("insert child: %v", err)
}
if _, err := s.Trash(userID, folderID); err != nil {
t.Fatalf("trash folder: %v", err)
}
if _, err := s.Repo.GetFile(userID, childID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("enfant après trash dossier : attendu NOT_FOUND, got %v", err)
}
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 2 {
t.Fatalf("corbeille subtree: total=%d, attendu 2", total)
}
if _, err := s.Restore(userID, folderID); err != nil {
t.Fatalf("restore folder: %v", err)
}
if _, err := s.Repo.GetFile(userID, childID); err != nil {
t.Fatalf("enfant après restore dossier: %v", err)
}
}
func TestTrashForeignIsNotFound(t *testing.T) {
s := newServiceStore(t)
owner := mustCreateUser(t, s.Repository, "trash-owner")
other := mustCreateUser(t, s.Repository, "trash-other")
fileID := mustInsertFile(t, s, owner, "secret.pdf")
if _, err := s.Trash(other, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("trash autrui : attendu NOT_FOUND, got %v", err)
}
if _, err := s.Restore(other, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("restore autrui : attendu NOT_FOUND, got %v", err)
}
if _, err := s.Purge(other, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("purge autrui : attendu NOT_FOUND, got %v", err)
}
if _, err := s.Repo.GetFile(owner, fileID); err != nil {
t.Fatalf("fichier owner intact: %v", err)
}
}
func TestDeleteLegacyMapsToTrash(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-legacy")
device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000001")
fileID := mustInsertFile(t, s, userID, "legacy.pdf")
// delete_resource → trash (restaurable, visible en corbeille).
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
})
if err != nil {
t.Fatalf("apply: %v", err)
}
if res.Applied != 1 || res.Failed != nil {
t.Fatalf("résultat inattendu: %+v", res)
}
if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("GetFile après delete legacy : attendu NOT_FOUND, got %v", err)
}
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 {
t.Fatalf("delete legacy doit apparaître en corbeille")
}
// Re-delete (déjà trashé) → no-op idempotent, pas NOT_FOUND.
res, err = s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
})
if err != nil {
t.Fatalf("re-apply: %v", err)
}
if res.Applied != 1 || res.Failed != nil {
t.Fatalf("re-delete trashé doit être no-op: %+v", res)
}
}
func TestSyncOpsTrashRestorePurge(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-ops")
other := mustCreateUser(t, s.Repository, "trash-ops-other")
device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000002")
fileID := mustInsertFile(t, s, userID, "ops.pdf")
foreignID := mustInsertFile(t, s, other, "foreign.pdf")
apply := func(op, resID string) SyncResult {
t.Helper()
res, err := s.ApplyBatch(userID, device, []SyncOperation{
syncOp(repository.NewID(), resID, op, "file", map[string]any{}),
})
if err != nil {
t.Fatalf("apply %s: %v", op, err)
}
return res
}
if res := apply(OpTrashResource, fileID); res.Applied != 1 || res.Failed != nil {
t.Fatalf("trash op: %+v", res)
}
// Trash d'autrui → halt NOT_FOUND.
if res := apply(OpTrashResource, foreignID); res.Failed == nil || res.Failed.Code != "NOT_FOUND" {
t.Fatalf("trash autrui doit halter NOT_FOUND: %+v", res)
}
if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil {
t.Fatalf("restore op: %+v", res)
}
if _, err := s.Repo.GetFile(userID, fileID); err != nil {
t.Fatalf("fichier restauré via op: %v", err)
}
// Restore d'un live → no-op succès.
if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil {
t.Fatalf("restore live doit être no-op: %+v", res)
}
// Restore d'inexistant → no-op (convergence).
if res := apply(OpRestoreResource, repository.NewID()); res.Applied != 1 || res.Failed != nil {
t.Fatalf("restore inexistant doit être no-op: %+v", res)
}
// Purge d'un live → détruit.
if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil {
t.Fatalf("purge op: %+v", res)
}
if owned, _ := s.Repo.ExistsOwnerAny(userID, fileID); owned {
t.Fatal("purge doit détruire la ligne")
}
// Purge d'inexistant → no-op.
if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil {
t.Fatalf("purge inexistant doit être no-op: %+v", res)
}
}
func TestPurgeRemovesPhysicalFiles(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-physical")
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("hello")), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
live := filepath.Join(s.UploadDir, userID, dto.ID+".txt")
if _, err := os.Stat(live); err != nil {
t.Fatalf("live absent: %v", err)
}
if _, err := s.Purge(userID, dto.ID); err != nil {
t.Fatalf("purge: %v", err)
}
if _, err := os.Stat(live); !os.IsNotExist(err) {
t.Fatalf("octets live doivent être supprimés: %v", err)
}
}
func TestUploadOverwriteCreatesVersionsCappedAt3(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-versions")
v1, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
if err != nil {
t.Fatalf("upload v1: %v", err)
}
// Le premier upload (création) ne crée pas de version.
if vers, err := s.ListVersions(userID, v1.ID); err != nil || len(vers) != 0 {
t.Fatalf("création ne doit pas versionner: %+v %v", vers, err)
}
contents := []string{"BBBB", "CCCCC", "DDDDDD", "EEEEEEE"}
for i, c := range contents {
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte(c)), "", v1.ID)
if err != nil {
t.Fatalf("overwrite %d: %v", i, err)
}
if dto.Size != int64(len(c)) {
t.Fatalf("overwrite %d: taille=%d", i, dto.Size)
}
}
vers, err := s.ListVersions(userID, v1.ID)
if err != nil {
t.Fatalf("list versions: %v", err)
}
if len(vers) != 3 {
t.Fatalf("versions = %d, attendu 3 (plafond N=3)", len(vers))
}
// Les 3 conservées sont les plus récentes : AAA a été élaguée.
// Ordre décroissant : version_no 4,3,2 → tailles 6,5,4.
wantSizes := []int64{6, 5, 4}
for i, v := range vers {
if v.Size != wantSizes[i] {
t.Errorf("version[%d].size = %d, attendu %d", i, v.Size, wantSizes[i])
}
}
// 3 fichiers figés sur disque (AAA élaguée avec sa ligne).
verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", v1.ID+"_v*"))
if len(verFiles) != 3 {
t.Errorf("fichiers versionnés = %d, attendu 3 (%v)", len(verFiles), verFiles)
}
}
func TestRestoreVersion(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-restore-ver")
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
if err != nil {
t.Fatalf("upload v1: %v", err)
}
if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBBB")), "", dto.ID); err != nil {
t.Fatalf("overwrite: %v", err)
}
vers, err := s.ListVersions(userID, dto.ID)
if err != nil || len(vers) != 1 {
t.Fatalf("versions: %+v %v", vers, err)
}
restored, err := s.RestoreVersion(userID, dto.ID, vers[0].VersionNo)
if err != nil {
t.Fatalf("restore version: %v", err)
}
if restored.Size != 3 {
t.Fatalf("live restauré taille=%d, attendu 3", restored.Size)
}
raw, err := os.ReadFile(filepath.Join(s.UploadDir, userID, dto.ID+".txt"))
if err != nil {
t.Fatalf("read live: %v", err)
}
if string(raw) != "AAA" {
t.Fatalf("contenu live = %q, attendu AAA", raw)
}
// L'ancien actuel (BBBB) a été à son tour versionné.
vers2, err := s.ListVersions(userID, dto.ID)
if err != nil || len(vers2) != 2 {
t.Fatalf("versions après restore: %+v %v", vers2, err)
}
if _, err := s.RestoreVersion(userID, dto.ID, 999); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("restore version inconnue : attendu NOT_FOUND, got %v", err)
}
}
func TestUploadToTrashedIsNotFound(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-upload-guard")
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
if _, err := s.Trash(userID, dto.ID); err != nil {
t.Fatalf("trash: %v", err)
}
if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBB")), "", dto.ID); !errors.Is(err, repository.ErrNotFound) {
t.Fatalf("upload vers trashé : attendu NOT_FOUND, got %v", err)
}
}
func backdateTrash(t *testing.T, s *Resources, resourceID string, ago time.Duration) {
t.Helper()
if _, err := s.Repository.Resources.DB.Exec(
`UPDATE resources SET deleted_at = NOW() - ($1 || ' seconds')::interval WHERE resource_id = $2`,
int(ago.Seconds()), resourceID,
); err != nil {
t.Fatalf("backdate: %v", err)
}
}
func TestPurgeExpiredTrash(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "trash-expire")
old, err := s.Upload(userID, multipartFileHeader(t, "vieux.txt", []byte("old")), "", "")
if err != nil {
t.Fatalf("upload vieux: %v", err)
}
fresh, err := s.Upload(userID, multipartFileHeader(t, "frais.txt", []byte("new")), "", "")
if err != nil {
t.Fatalf("upload frais: %v", err)
}
if _, err := s.Trash(userID, old.ID); err != nil {
t.Fatalf("trash vieux: %v", err)
}
if _, err := s.Trash(userID, fresh.ID); err != nil {
t.Fatalf("trash frais: %v", err)
}
backdateTrash(t, s, old.ID, 31*24*time.Hour)
n, err := s.PurgeExpiredTrash(TrashRetention)
if err != nil {
t.Fatalf("purge expired: %v", err)
}
if n != 1 {
t.Fatalf("purgés = %d, attendu 1", n)
}
if owned, _ := s.Repo.ExistsOwnerAny(userID, old.ID); owned {
t.Fatal("vieux doit être détruit")
}
if _, _, err := s.ListTrashed(userID, 1, 50); err != nil {
t.Fatalf("list: %v", err)
}
if _, err := s.Repo.GetFile(userID, fresh.ID); err == nil {
// Frais trashé mais pas expiré : invisible en lecture, présent en corbeille.
t.Fatal("frais doit rester trashé (invisible en lecture)")
}
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 {
t.Fatalf("corbeille doit garder le frais: total=%d", total)
}
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, old.ID+".txt")); !os.IsNotExist(err) {
t.Fatal("octets du purgé doivent être supprimés")
}
}
+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 UPLOAD_DIR: /app/uploads
MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50} MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50}
OCR_LANG: ${OCR_LANG:-fra+eng} OCR_LANG: ${OCR_LANG:-fra+eng}
AUTH_SECRET: ${AUTH_SECRET:?AUTH_SECRET requis (voir backend/.env.example)} AUTH_SECRET: ${AUTH_SECRET:-dev-secret-change-me-please-set-in-prod}
ADMIN_USERNAME: ${ADMIN_USERNAME:?ADMIN_USERNAME requis au premier démarrage} ADMIN_USERNAME: ${ADMIN_USERNAME:-admin}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:?ADMIN_PASSWORD requis au premier démarrage} ADMIN_PASSWORD: ${ADMIN_PASSWORD:-change-me}
volumes: volumes:
- backend-uploads:/app/uploads - backend-uploads:/app/uploads
depends_on: depends_on:
+48 -16
View File
@@ -18,8 +18,8 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
- **User-first (V1 finale)** : le device s'enregistre d'abord (`POST /devices`) avec son identité **générée localement** (`device_user_id` 32-hex mobile) — **réponse `{ "deviceId" }` uniquement, sans token**. Puis le client appelle `POST /auth/login` (`username` + `password` + `device_id`) pour obtenir son token **paseto** v4-local. Requêtes suivantes : `Authorization: Bearer <token>` (toutes les routes **sauf `/health`, `/devices`, `/auth/login`**). - **User-first (V1 finale)** : le device s'enregistre d'abord (`POST /devices`) avec son identité **générée localement** (`device_user_id` 32-hex mobile) — **réponse `{ "deviceId" }` uniquement, sans token**. Puis le client appelle `POST /auth/login` (`username` + `password` + `device_id`) pour obtenir son token **paseto** v4-local. Requêtes suivantes : `Authorization: Bearer <token>` (toutes les routes **sauf `/health`, `/devices`, `/auth/login`**).
- **Claims du token** : le **subject = `user_id`** (AUTORISE, clé de scoping de toutes les ressources) ; `device_id` est un **claim secondaire, porté mais NON autorisant seul** (idempotence outbox + jobs OCR). Résolu par middleware `RequireAuth` qui vérifie aussi que le compte existe toujours (`deleted_at IS NULL`). - **Claims du token** : le **subject = `user_id`** (AUTORISE, clé de scoping de toutes les ressources) ; `device_id` est un **claim secondaire, porté mais NON autorisant seul** (idempotence outbox + jobs OCR). Résolu par middleware `RequireAuth` qui vérifie aussi que le compte existe toujours (`deleted_at IS NULL`).
- **TTL : 7 jours, sans refresh.** À expiration, le client re-logine (`POST /auth/login`). Le changement de mot de passe (`PATCH /users/me/password`) **n'invalide pas** les tokens déjà émis — limite V1 assumée (pas de liste de révocation) jusqu'à l'expiration. - **TTL : 7 jours, sans refresh.** À expiration, le client re-logine (`POST /auth/login`). **Révocation V3 (S6)** : `PATCH /users/me/password` bumpe `users.token_version` — tous les tokens antérieurs deviennent 401 (`token revoked`), y compris non expirés ; le client doit se reconnecter (le claim `tv` porte la version, les tokens pré-V3 sans `tv` valent 0 et survivent jusqu'au premier changement de mot de passe).
- Au login, `devices.user_id` mémorise le **dernier user connecté** (INFORMATIF uniquement, jamais autorisant — recommande `POST /devices` → `POST /auth/login` pour un nouveau device, sans réutiliser le device d'un autre compte). - Au login, `devices.user_id` mémorise le **dernier user connecté** (INFORMATIF uniquement, jamais autorisant — recommande `POST /devices` → `POST /auth/login` pour un nouveau device, sans réutiliser le device d'un autre compte). **Révocation V3 (S6 A1)** : `DELETE /devices/:id` supprime l'enregistrement (téléphone perdu) — avec `EnforceDeviceExists` (prod), les tokens du device deviennent 401 et son login est refusé ; seule une ré-inscription explicite (`POST /devices`) restaure l'accès. `GET /devices` liste les devices du compte (dernier login = ce compte).
- **Identifiants** : `resource_id`, `device_user_id`, `user_id`, `is_admin`… = **TEXT opaque 32-hex minuscule**, `^[0-9a-f]{32}$`. Le mobile génère toujours `lower(hex(randomblob(16)))` ; le serveur stocke **tel quel**, sans conversion UUID (cf. note V2.md). Contrainte serveur : `CHECK (col ~ '^[0-9a-f]{32}$')` sur toutes les colonnes id + FK. - **Identifiants** : `resource_id`, `device_user_id`, `user_id`, `is_admin`… = **TEXT opaque 32-hex minuscule**, `^[0-9a-f]{32}$`. Le mobile génère toujours `lower(hex(randomblob(16)))` ; le serveur stocke **tel quel**, sans conversion UUID (cf. note V2.md). Contrainte serveur : `CHECK (col ~ '^[0-9a-f]{32}$')` sur toutes les colonnes id + FK.
- **Usernames** : `username` = forme affichée ; l'unicité et la résolution portent sur `username_normalized` (lowercase + trim). Résolution d'un destinataire : `GET /users/resolve?username=` (exact uniquement, jamais de listing ni de préfixe — pas d'énumération de comptes). - **Usernames** : `username` = forme affichée ; l'unicité et la résolution portent sur `username_normalized` (lowercase + trim). Résolution d'un destinataire : `GET /users/resolve?username=` (exact uniquement, jamais de listing ni de préfixe — pas d'énumération de comptes).
- **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. - **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.
@@ -34,16 +34,40 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
| POST | `/auth/login` | `{ "username", "password", "device_id" }` | `{ "token", "expires_at" (ms), "user": { "id", "username", "is_admin" } }` | `UNAUTHORIZED` / `INVALID_DEVICE_ID` | | POST | `/auth/login` | `{ "username", "password", "device_id" }` | `{ "token", "expires_at" (ms), "user": { "id", "username", "is_admin" } }` | `UNAUTHORIZED` / `INVALID_DEVICE_ID` |
| GET | `/shares/links/:token` | — (public, sans auth) | `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }` | `NOT_FOUND` (inconnu/révoqué/expiré) | | GET | `/shares/links/:token` | — (public, sans auth) | `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }` | `NOT_FOUND` (inconnu/révoqué/expiré) |
| GET | `/users/resolve` | query `username` (obligatoire) | `{ "id", "username" }` | `NOT_FOUND` | | GET | `/users/resolve` | query `username` (obligatoire) | `{ "id", "username" }` | `NOT_FOUND` |
| PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` | `INVALID_PASSWORD` (403) | | PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` (+ révocation globale des tokens) | `INVALID_PASSWORD` (403) |
| GET | `/users/me/usage` | — | `{ usedBytes, quotaBytes, fileCount, trashCount, trashedBytes }` (calculé, corbeille détaillée) | — |
| GET | `/devices` | — | `[{ deviceId, lastSeenAt }]` (dernier login = ce compte) | — |
| DELETE | `/devices/:id` | — (téléphone perdu, A1) | `{ "id" }` | `NOT_FOUND` (absent/autre compte — pas d'énumération) |
| GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — | | GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — |
| GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` | | GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` |
| DELETE | `/files/:id` | — | `{ "id": "…" }` | `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) |
| GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — | | GET | `/files/:id/preview` | — (JPEG 512, `inline`, `Cache-Control: private, max-age=3600`, viewer+) | vignette (`image/jpeg`) — générée à la demande (images pur Go, PDF page 1 via `pdftoppm`), cachée jusqu'au prochain changement | `NOT_FOUND` (invisible/metadata-only), `NO_PREVIEW` (type non prévisualisable — icône côté client, sans réessai) |
| POST | `/export` | `{ "password" }` (8+ caractères, en corps — jamais en query) | zip AES-256 streamé (`application/zip`, `attachment`) — fichiers vifs possédés + `manifest.json`, tout chiffré | `INVALID_REQUEST` (mot de passe court/malformé) |
| DELETE | `/files/:id` | query `mode?` (`trash` défaut, `purge` = définitif) | `{ "id": "…" }` | `NOT_FOUND` |
| POST | `/files/:id/restore` | — | `{ "id": "…" }` | `NOT_FOUND` (absente/étrangère/purgée ; vivante = succès idempotent) |
| GET | `/trash` | query `page?`, `pageSize?` | `TrashDto[]` (`{ id, type, name, size, trashedAt, updatedAt }` + `meta`) | — |
| GET | `/files/:id/versions` | — (parent live uniquement) | `VersionDto[]` (`{ versionNo, size, mimeType, createdAt }`, plus récent d'abord) | `NOT_FOUND` |
| POST | `/files/:id/versions/:n/restore` | — (l'actuel est à son tour versionné) | `FileDto` | `NOT_FOUND` |
| GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?`, facettes V3 : `issuer?`, `from?`/`to?` (ISO `YYYY-MM-DD`, sur faits date/échéance + recouvrement périodes `YYYY-MM`), `min_amount?`/`max_amount?` (numériques), `doc_type?` (vocabulaire suggéré) | `FileDto[]` (+ `meta`, rang : nom exact > TS > fait sûr > fait douteux) | `INVALID_REQUEST` (facette malformée) |
| GET | `/files/folders` | — | `FolderDto[]` (racines) | — | | GET | `/files/folders` | — | `FolderDto[]` (racines) | — |
| POST | `/files/upload` | multipart : `file` (uri/name/type), `folderId?` | `FileDto` | `FILE_TOO_LARGE` | | POST | `/files/upload` | multipart : `file` (uri/name/type), `folderId?` | `FileDto` | `FILE_TOO_LARGE` |
| POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — | | POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — |
| GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` | | GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` |
| GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` | | GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` |
| GET | `/files/:id/facts` | — (viewer+, même portée que l'OCR) | `Fact[]` (`{ factType: date&#124;due_date&#124;period&#124;amount&#124;issuer&#124;reference&#124;doc_type, valueText?, valueNum?, valueDate? (ISO), confidence (0..1), origin: auto&#124;user }`, `[]` si rien d'extractible) | `NOT_FOUND` (trashé/absent/étranger) |
| PATCH | `/files/:id/facts` | `{ facts: [{ factType, valueText?, valueNum?, valueDate?, confidence? }] }` (jeu `user` complet, full-replace, editor+) | `Fact[]` (jeu complet auto + user) | `NOT_FOUND` (viewer-/absent/trashé), `INVALID_REQUEST` (type inconnu, date non ISO, fait sans valeur, corps malformé) |
| GET | `/files/:id/relations` | — (owner uniquement) | `Relation[]` (`{ id, otherId, type: same_scan&#124;duplicate_of&#124;same_issuer&#124;same_reference, confidence, createdBy: auto&#124;user, otherName, otherType, otherSize }`, réconcilié à la lecture, autre bout vivant) | `NOT_FOUND` (étranger/trashé/absent — pas d'énumération) |
| POST | `/files/:id/relations/verdict` | `{ otherId, linkType, confirmed }` | `Relation[]` (jeu réconcilié) | `NOT_FOUND` (bouts non possédés), `INVALID_REQUEST` (type/paire invalide, corps malformé) |
| GET | `/duplicates` | — (compte connecté) | `DuplicateGroup[]` (`{ contentHash, count, totalBytes, reclaimableBytes, files: [{ id, name, size, updatedAt }] }`, plus gros d'abord, `[]` si propre) | — |
| 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 | — | | POST | `/sync/ops` | voir §6 | voir §6 | — |
| GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — | | GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — |
@@ -59,6 +83,7 @@ type FileDto = {
mimeType?: string | null; mimeType?: string | null;
folderId?: string | null; // resource_id 32-hex folderId?: string | null; // resource_id 32-hex
tags?: string[]; tags?: string[];
hasContent: boolean; // V2 : octets vus présents (lazy healing, FALSE = jamais constatés)
createdAt?: string; createdAt?: string;
updatedAt?: string; updatedAt?: string;
}; };
@@ -83,6 +108,7 @@ type FileOcr = { text: string; updatedAt?: string | null };
- `fileId` inconnu/pas du user → `NOT_FOUND`. Fichier physique introuvable (ex. suppression manuelle sous `UPLOAD_DIR`) → job `failed` `"file not readable"`. Le job est créé par le device courant (`ocr_jobs.device_id`) mais la validation de la ressource est scopée par le **user**. - `fileId` inconnu/pas du user → `NOT_FOUND`. Fichier physique introuvable (ex. suppression manuelle sous `UPLOAD_DIR`) → job `failed` `"file not readable"`. Le job est créé par le device courant (`ocr_jobs.device_id`) mais la validation de la ressource est scopée par le **user**.
- **Le texte atterrit sur la ressource** : à la complétion (`done` avec texte non vide), le worker écrit l'extrait trimé dans `resources.ocr_text` (et **bump `updated_at`**, d'où une injection dans le delta outbox/snapshot). `ocr_jobs.text` reste l'historique du job. - **Le texte atterrit sur la ressource** : à la complétion (`done` avec texte non vide), le worker écrit l'extrait trimé dans `resources.ocr_text` (et **bump `updated_at`**, d'où une injection dans le delta outbox/snapshot). `ocr_jobs.text` reste l'historique du job.
- **`GET /files/:id/ocr`** → `FileOcr { text, updatedAt }` : l'extrait server-side du fichier, lisible par le **possédant ET les grantees** (`viewer+`, même portée que `GET /files/:id` ; `text` `""` si pas encore extrait). Un **second device** rapatrie ainsi le texte d'un OCR fait par un autre device (ou par la ressource partagée) **sans re-téléverser les octets ni re-soumettre de job** — le client Kotlin le fait en tête de `OcrRepository.syncFromServer`/`processAuto` et du viewer (`OcrViewModel`). - **`GET /files/:id/ocr`** → `FileOcr { text, updatedAt }` : l'extrait server-side du fichier, lisible par le **possédant ET les grantees** (`viewer+`, même portée que `GET /files/:id` ; `text` `""` si pas encore extrait). Un **second device** rapatrie ainsi le texte d'un OCR fait par un autre device (ou par la ressource partagée) **sans re-téléverser les octets ni re-soumettre de job** — le client Kotlin le fait en tête de `OcrRepository.syncFromServer`/`processAuto` et du viewer (`OcrViewModel`).
- **Faits génériques V3 (`GET /files/:id/facts`)** : après chaque OCR `done`, le worker en dérive des faits vérifiables (règles FR, sans ML : dates ISO, échéances (`due_date` si mot-clé `échéance|à payer avant|date limite`), périodes (`2026-03`), montants € (confiance 0.9 si mot-clé `total|montant|à payer`), émetteurs (lignes capitales), références (`facture:FA-…`, `siret:…`, IBAN masqué `rib:••••1234`), `doc_type` suggéré (seuil de score, jamais gate). Chaque fait porte `confidence` (0..1) et `origin` (`auto` remplacé à chaque passe, `user` intouchable — corrections S3). Même portée que l'OCR (`viewer+`) ; `[]` si rien d'extractible. Backfill borné au boot (OCR d'avant la V3).
## 6. Contrat de sync (outbox + snapshot) ## 6. Contrat de sync (outbox + snapshot)
@@ -104,22 +130,27 @@ 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 | trash_resource | restore_resource | purge_resource | correct_facts` (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. - **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. - **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). - Réponse : `2xx` avec `{ "applied": int, "failed": { "operation_id": "…32-hex", "code": string, "message": string } | null, "conflicts"?: [{ "operation_id", "resource_id", "serverName", "serverUpdatedAt" }] }` (`applied` = index de la prochaine op à envoyer ; `conflicts` = renames LWW appliqués malgré une `baseUpdatedAt` périmée — non-fataux, le batch continue).
- Côté client, le `pushStatus` (pending/synced/failed) des shares/share_links est **dérivé** de l'état des opérations de l'outbox ; **dead-letter immédiat** sur erreur 4xx non-idempotente (`failed`, non resélectionné ; `attempts` reste un compteur diagnostic, pas un seuil) — seul le transitoire (`NETWORK_ERROR`/5xx) est rejoué avec backoff. **Côté serveur, les ops partage créent un état réel** (tables `shares`/`share_links`, migration `000009`) — l'outbox est le seul chemin d'écriture des droits. - Côté client, le `pushStatus` (pending/synced/failed) des shares/share_links est **dérivé** de l'état des opérations de l'outbox ; **dead-letter immédiat** sur erreur 4xx non-idempotente (`failed`, non resélectionné ; `attempts` reste un compteur diagnostic, pas un seuil) — seul le transitoire (`NETWORK_ERROR`/5xx) est rejoué avec backoff. **Côté serveur, les ops partage créent un état réel** (tables `shares`/`share_links`, migration `000009`) — l'outbox est le seul chemin d'écriture des droits.
- Sémantique d'application (côté serveur) : - Sémantique d'application (côté serveur) :
- `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. - `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. `payload.scanSessionId` (32-hex, optionnel, V3 S5) = session de scan opaque — le serveur en déduit les arêtes `same_scan` (même session, même compte) ; format invalide → `INVALID_REQUEST`.
- `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). - `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). `payload = { "name", "baseUpdatedAt"? }` (V3 S6 A4 : `updated_at` ms vu par le client — périmé au-delà de 2 s de tolérance → rename appliqué quand même + signalé en `conflicts`, transparence sans CRDT). `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. - `delete_resource` : **legacy → mappé vers `trash_resource`** (corbeille, restaurable, même idempotence : absent/déjà trashé = succès, vivant d'autrui = `NOT_FOUND` halt).
- **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`). - **Corbeille V3** (`trash_resource` / `restore_resource` / `purge_resource`, owner-only) : `trash` pose `deleted_at` sur la ressource **et son subtree** (dossier → contenu) ; `restore` lève le flag sur la ressource, son subtree **et sa chaîne d'ancêtres** (un fichier restauré dont le dossier est encore trashé resterait injoignable) ; `purge` détruit lignes + versions + octets. Sémantique : absent → no-op (`trash`/`restore`/`purge`), vivant d'autrui → `NOT_FOUND` halt, `restore` d'un live → no-op succès. Une ressource trashée reste `NOT_FOUND` en lecture normale, visible seulement via `GET /trash`. Passe serveur : destruction définitive après 30j (`TrashRetention`).
- **Corrections V3** (`correct_facts`, editor+) : `payload = { "facts": [{ "factType", "valueText"?, "valueNum"?, "valueDate"? (ISO `YYYY-MM-DD`), "confidence"? }] }` — remplace le jeu `user` complet (full-replace, jamais de diff ; jeu vide = efface les corrections, l'auto survit). Mêmes gardes qu'`update_metadata` (viewer- → `NOT_FOUND` halt) ; fait invalide (type inconnu, date non ISO, sans valeur) → `INVALID_REQUEST` avec arrêt du batch. Le client corrige en un tap depuis la fiche document et pousse dans la même transaction Room que l'écriture optimiste.
- **Graphe V3 (lecture)** : `GET /files/:id/relations` (owner-only) réconcilie puis renvoie les arêtes vivantes — `same_scan` (même `scan_session_id`, 1.0), `duplicate_of` (même SHA-256, 1.0 — hash posé à l'upload + backfill boot), `same_issuer`/`same_reference` (faits égaux, confiance = min, auto ignoré si correction `user` du même type — miroir de l'affichage). Stockage canonique (`from < to`), verdicts `user` préservés et bloquant toute re-création auto, élagage des auto périmées. `POST /files/:id/relations/verdict` (confirmé → 1.0, infirmé → 0.0 conservé). `version_of` non matérialisé : les versions vivent DANS la ressource (`resource_versions`). `GET /duplicates` (compte connecté) : groupes par hash avec gain récupérable (total − plus gros).
- **Versions V3** : chaque overwrite d'octets (upload ciblé) fige l'ancienne génération (`resource_versions`, N=3, élagage auto) ; `POST /files/:id/versions/:n/restore` recopie vers le live (l'actuel est à son tour versionné). Upload ciblé vers une ressource trashée → `NOT_FOUND` (jamais de résurrection d'octets).
- **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). - `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`). - `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**. - `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. - Validation (deuxième champ `operation_id`, hex32 pour `resource_id` **et** `operation_id`, enum `operation`) → échec `INVALID_REQUEST` avec arrêt du batch.
- Nom déjà pris (même parent, ou à la racine) → échec `NAME_CONFLICT`.** - Nom déjà pris (même parent, ou à la racine) → échec `NAME_CONFLICT`.**
- **Lien public** : `GET /shares/links/:token` est **sans authentification** (résolution publique d'un lien) et renvoie `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }`. `NOT_FOUND` si le lien est inconnu, révoqué ou expiré. - **Lien public** : `GET /shares/links/:token` est **sans authentification** (résolution publique d'un lien) et renvoie `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }`. `NOT_FOUND` si le lien est inconnu, révoqué ou expiré. Le client partage les liens sous forme de deep-link `kazier://share/<token>` (custom scheme, pas d'App Links https) : indépendant du domaine du serveur, donc compatible self-hosting (chaque instance a son propre host).
### 6.2 Snapshot — `GET /sync/permissions?after=<cached_at_ms>` ### 6.2 Snapshot — `GET /sync/permissions?after=<cached_at_ms>`
@@ -153,12 +184,13 @@ type ResourcePermission = {
### 6.3 Placements ### 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). - 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 ## 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). - Authentification : `UNAUTHORIZED` (**401** — token manquant/invalide/expiré/**révoqué** (mot de passe changé, device révoqué), 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`). - Ressources : `NOT_FOUND` (404), `NO_PREVIEW` (404 — type non prévisualisable : txt, binaire inconnu, PDF sans `pdftoppm`), `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), `QUOTA_EXCEEDED` (413 — créations au-delà de `storage_quota_bytes`, 10 Go par défaut ; overwrites ciblées exemptées, gain net ~nul), `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é. - 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). - **V1 finale : toutes les routes sont réelles** (pas de 501 restant).
@@ -166,4 +198,4 @@ type ResourcePermission = {
- `POST /auth/login` : le **device doit exister** (`POST /devices` d'abord, sinon 400 `INVALID_DEVICE_ID`). La vérification du mot de passe est **constant-time** (`argon2id`, comparaison `subtle`) et le délai est **égalisé** entre « username inconnu » et « mauvais mot de passe » (vérification contre un dummy-hash) — les deux produisent exactement la même réponse 401. - `POST /auth/login` : le **device doit exister** (`POST /devices` d'abord, sinon 400 `INVALID_DEVICE_ID`). La vérification du mot de passe est **constant-time** (`argon2id`, comparaison `subtle`) et le délai est **égalisé** entre « username inconnu » et « mauvais mot de passe » (vérification contre un dummy-hash) — les deux produisent exactement la même réponse 401.
- `GET /users/resolve` : résolution **exacte** du `username_normalized` uniquement ; ne renvoie **jamais** `email` ni `is_admin` (ni listing, ni préfixe → pas d'énumération de comptes). - `GET /users/resolve` : résolution **exacte** du `username_normalized` uniquement ; ne renvoie **jamais** `email` ni `is_admin` (ni listing, ni préfixe → pas d'énumération de comptes).
- `PATCH /users/me/password` : exige `current_password` (mauvais curl → 403). Minimum 8 caractères. **Limite V1** : tokens émis non révoqués (validité 7 j), et `is_admin`/`ADMIN_*` non modifiables par API. - `PATCH /users/me/password` : exige `current_password` (mauvais curl → 403). Minimum 8 caractères. **V3 S6** : bumpe `token_version` (tous les tokens antérieurs révoqués — le client se reconnecte) ; `is_admin`/`ADMIN_*` non modifiables par API.
+26 -3
View File
@@ -1,7 +1,7 @@
[tasks.up_backend] [tasks.up_backend]
description = "Start PostgreSQL + backend API (Go/Gin)" description = "Start PostgreSQL + backend API (Go/Gin)"
run = [ 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", "cd backend && go run cmd/server/main.go",
] ]
@@ -21,9 +21,32 @@ set -euo pipefail
./gradlew :app:assembleDebug -q ./gradlew :app:assembleDebug -q
APK="app/build/outputs/apk/debug/app-debug.apk" APK="app/build/outputs/apk/debug/app-debug.apk"
if [ "${usage_target?}" = "emulator" ]; then if [ "${usage_target?}" = "emulator" ]; then
adb -e install -r "$APK" ADB_FLAGS=(-e)
else else
adb -d install -r "$APK" ADB_FLAGS=(-d)
fi
# adb natif s'il fonctionne (PATH + binaire exécutable sur cet OS)...
if command -v adb >/dev/null 2>&1 && adb version >/dev/null 2>&1; then
adb "${ADB_FLAGS[@]}" install -r "$APK"
# ...sinon repli NixOS : l'adb du SDK est un binaire FHS dynamiquement
# lié, on l'exécute via steam-run (cf. local.properties pour sdk.dir).
elif command -v steam-run >/dev/null 2>&1; then
SDK_DIR="${ANDROID_SDK_ROOT:-${ANDROID_HOME:-}}"
if [ -z "$SDK_DIR" ] && [ -f local.properties ]; then
SDK_DIR="$(sed -n 's/^sdk\.dir=//p' local.properties | head -n 1)"
fi
if [ -z "$SDK_DIR" ] && [ -d "$HOME/Android/Sdk" ]; then
SDK_DIR="$HOME/Android/Sdk"
fi
if [ -z "$SDK_DIR" ] || [ ! -x "$SDK_DIR/platform-tools/adb" ]; then
echo "adb introuvable : définissez ANDROID_HOME ou sdk.dir dans local.properties." >&2
exit 1
fi
export LD_LIBRARY_PATH="${LD_LIBRARY_PATH:-}:$HOME/.nix-profile/lib:/run/opengl-driver/lib"
steam-run "$SDK_DIR/platform-tools/adb" "${ADB_FLAGS[@]}" install -r "$APK"
else
echo "adb ne fonctionne pas sur cet OS et steam-run est absent (NixOS)." >&2
exit 1
fi fi
''' '''
+5
View File
@@ -84,6 +84,11 @@ android {
} }
} }
// m19 : export du schéma Room (`app/schemas/`) pour détecter les dérives en CI.
ksp {
arg("room.schemaLocation", "$projectDir/schemas")
}
dependencies { dependencies {
implementation(libs.androidx.core.ktx) implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx) implementation(libs.androidx.lifecycle.runtime.ktx)
@@ -0,0 +1,730 @@
{
"formatVersion": 1,
"database": {
"version": 16,
"identityHash": "ec10fdb23d5da3a76a73222e9c404561",
"entities": [
{
"tableName": "folders",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `exists` INTEGER, `parent_resource_id` TEXT, `owner_id` TEXT, `sync_status` TEXT NOT NULL, `created_in_app` INTEGER NOT NULL DEFAULT 0, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "uri",
"columnName": "uri",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "exists",
"columnName": "exists",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "parentResourceId",
"columnName": "parent_resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "syncStatus",
"columnName": "sync_status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdInApp",
"columnName": "created_in_app",
"affinity": "INTEGER",
"notNull": true,
"defaultValue": "0"
},
{
"fieldPath": "addedAt",
"columnName": "added_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_folders_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_folders_uri",
"unique": true,
"columnNames": [
"uri"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_uri` ON `${TABLE_NAME}` (`uri`)"
},
{
"name": "index_folders_parent_resource_id",
"unique": false,
"columnNames": [
"parent_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_folders_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "user_preferences",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`key` TEXT NOT NULL, `value` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`key`))",
"fields": [
{
"fieldPath": "key",
"columnName": "key",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "value",
"columnName": "value",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"key"
]
},
"indices": [],
"foreignKeys": []
},
{
"tableName": "files",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `folder_resource_id` TEXT NOT NULL, `extension` TEXT, `size` INTEGER NOT NULL, `mime_type` TEXT, `exists` INTEGER, `last_modified` INTEGER, `owner_id` TEXT, `category` TEXT, `sync_status` TEXT NOT NULL, `content` TEXT, `processed` INTEGER NOT NULL, `ocr_text` TEXT, `ocr_attempts` INTEGER NOT NULL, `ocr_queued_at` INTEGER, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "uri",
"columnName": "uri",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "name",
"columnName": "name",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "folderResourceId",
"columnName": "folder_resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "extension",
"columnName": "extension",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "size",
"columnName": "size",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "mimeType",
"columnName": "mime_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "exists",
"columnName": "exists",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "lastModified",
"columnName": "last_modified",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "category",
"columnName": "category",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "syncStatus",
"columnName": "sync_status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "content",
"columnName": "content",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "processed",
"columnName": "processed",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ocrText",
"columnName": "ocr_text",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "ocrAttempts",
"columnName": "ocr_attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "ocrQueuedAt",
"columnName": "ocr_queued_at",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "addedAt",
"columnName": "added_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_files_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_files_uri",
"unique": true,
"columnNames": [
"uri"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_uri` ON `${TABLE_NAME}` (`uri`)"
},
{
"name": "index_files_folder_resource_id",
"unique": false,
"columnNames": [
"folder_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_folder_resource_id` ON `${TABLE_NAME}` (`folder_resource_id`)"
},
{
"name": "index_files_category",
"unique": false,
"columnNames": [
"category"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_category` ON `${TABLE_NAME}` (`category`)"
},
{
"name": "index_files_exists_processed_sync_status",
"unique": false,
"columnNames": [
"exists",
"processed",
"sync_status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` ON `${TABLE_NAME}` (`exists`, `processed`, `sync_status`)"
}
],
"foreignKeys": []
},
{
"tableName": "pending_operations",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_id` TEXT, `operation_id` TEXT NOT NULL, `ref_type` TEXT, `ref_id` INTEGER, `resource_id` TEXT, `resource_type` TEXT, `operation` TEXT NOT NULL, `payload` TEXT NOT NULL, `parent_resource_id` TEXT, `status` TEXT NOT NULL, `attempts` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "deviceId",
"columnName": "device_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "operationId",
"columnName": "operation_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "refType",
"columnName": "ref_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "refId",
"columnName": "ref_id",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "resourceType",
"columnName": "resource_type",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "operation",
"columnName": "operation",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "payload",
"columnName": "payload",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "parentResourceId",
"columnName": "parent_resource_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "attempts",
"columnName": "attempts",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_pending_operations_device_id_operation_id",
"unique": true,
"columnNames": [
"device_id",
"operation_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_pending_operations_device_id_operation_id` ON `${TABLE_NAME}` (`device_id`, `operation_id`)"
},
{
"name": "index_pending_operations_status",
"unique": false,
"columnNames": [
"status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_status` ON `${TABLE_NAME}` (`status`)"
},
{
"name": "index_pending_operations_resource_id",
"unique": false,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_pending_operations_resource_id_operation_status",
"unique": false,
"columnNames": [
"resource_id",
"operation",
"status"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` ON `${TABLE_NAME}` (`resource_id`, `operation`, `status`)"
},
{
"name": "index_pending_operations_parent_resource_id",
"unique": false,
"columnNames": [
"parent_resource_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "scan_sessions",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `root_folder_id` TEXT, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "rootFolderId",
"columnName": "root_folder_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_scan_sessions_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_sessions_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
}
],
"foreignKeys": []
},
{
"tableName": "scan_pages",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `session_id` INTEGER NOT NULL, `temp_uri` TEXT NOT NULL, `corners_json` TEXT NOT NULL, `width` INTEGER NOT NULL, `height` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, FOREIGN KEY(`session_id`) REFERENCES `scan_sessions`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
"fields": [
{
"fieldPath": "id",
"columnName": "id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "sessionId",
"columnName": "session_id",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "tempUri",
"columnName": "temp_uri",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "cornersJson",
"columnName": "corners_json",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "width",
"columnName": "width",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "height",
"columnName": "height",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "sortOrder",
"columnName": "sort_order",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "status",
"columnName": "status",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "createdAt",
"columnName": "created_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": true,
"columnNames": [
"id"
]
},
"indices": [
{
"name": "index_scan_pages_resource_id",
"unique": true,
"columnNames": [
"resource_id"
],
"orders": [],
"createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_pages_resource_id` ON `${TABLE_NAME}` (`resource_id`)"
},
{
"name": "index_scan_pages_session_id",
"unique": false,
"columnNames": [
"session_id"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_session_id` ON `${TABLE_NAME}` (`session_id`)"
},
{
"name": "index_scan_pages_sort_order",
"unique": false,
"columnNames": [
"sort_order"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_sort_order` ON `${TABLE_NAME}` (`sort_order`)"
}
],
"foreignKeys": [
{
"table": "scan_sessions",
"onDelete": "CASCADE",
"onUpdate": "NO ACTION",
"columns": [
"session_id"
],
"referencedColumns": [
"id"
]
}
]
},
{
"tableName": "resource_permissions",
"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`resource_id` TEXT NOT NULL, `resource_type` TEXT NOT NULL, `effective_access` TEXT NOT NULL, `owner_id` TEXT, `shared_by_id` TEXT, `expires_at` INTEGER, `cached_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`resource_id`))",
"fields": [
{
"fieldPath": "resourceId",
"columnName": "resource_id",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "resourceType",
"columnName": "resource_type",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "effectiveAccess",
"columnName": "effective_access",
"affinity": "TEXT",
"notNull": true
},
{
"fieldPath": "ownerId",
"columnName": "owner_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "sharedById",
"columnName": "shared_by_id",
"affinity": "TEXT",
"notNull": false
},
{
"fieldPath": "expiresAt",
"columnName": "expires_at",
"affinity": "INTEGER",
"notNull": false
},
{
"fieldPath": "cachedAt",
"columnName": "cached_at",
"affinity": "INTEGER",
"notNull": true
},
{
"fieldPath": "updatedAt",
"columnName": "updated_at",
"affinity": "INTEGER",
"notNull": true
}
],
"primaryKey": {
"autoGenerate": false,
"columnNames": [
"resource_id"
]
},
"indices": [
{
"name": "index_resource_permissions_expires_at",
"unique": false,
"columnNames": [
"expires_at"
],
"orders": [],
"createSql": "CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` ON `${TABLE_NAME}` (`expires_at`)"
}
],
"foreignKeys": []
}
],
"views": [],
"setupQueries": [
"CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
"INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'ec10fdb23d5da3a76a73222e9c404561')"
]
}
}

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