Files
Kazier/backend/service/sync.go
T
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

684 lines
24 KiB
Go

package service
import (
"encoding/json"
"errors"
"log"
"regexp"
"time"
"github.com/kazier/backend/repository"
)
var resourceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
// Ops de l'outbox (docs/api-v1.md §6.1).
const (
OpCreateResource = "create_resource"
OpUpdateMetadata = "update_metadata"
OpDeleteResource = "delete_resource"
OpMoveResource = "move_resource"
OpShare = "share"
OpRevokeShare = "revoke_share"
OpUpdateShare = "update_share"
OpCreateLink = "create_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"
)
// SyncOperation is one outbox entry (shadow of mobile PendingOperationRow).
type SyncOperation struct {
OperationID string `json:"operation_id"`
RefType *string `json:"ref_type"`
RefID *int64 `json:"ref_id"`
ResourceID *string `json:"resource_id"`
ResourceType *string `json:"resource_type"`
Operation string `json:"operation"`
Payload json.RawMessage `json:"payload"`
}
// FailedOperation reports the first non-idempotent failure.
type FailedOperation struct {
OperationID string `json:"operation_id"`
Code string `json:"code"`
Message string `json:"message"`
}
// SyncResult is the outbox response: applied = index of the next op to send.
type SyncResult struct {
Applied int `json:"applied"`
Failed *FailedOperation `json:"failed,omitempty"`
}
type createResourcePayload struct {
Name string `json:"name"`
ParentResourceID string `json:"parentResourceId"` // dossier parent (racine si vide), cf. docs/api-v1.md §6.1
MimeType string `json:"mimeType"`
Extension string `json:"extension"`
}
type renamePayload struct {
Name string `json:"name"`
}
type movePayload struct {
ToFolderResourceID string `json:"toFolderResourceId"`
}
type sharePayload struct {
GranteeUserID string `json:"granteeUserId"`
GranteeGroupID string `json:"granteeGroupId"`
Access string `json:"access"`
Inherit *bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
}
type revokeSharePayload struct {
GranteeUserID string `json:"granteeUserId"`
}
type linkPayload struct {
Token string `json:"token"`
Access string `json:"access"`
ExpiresAt *int64 `json:"expiresAt"`
}
type revokeLinkPayload struct {
Token string `json:"token"`
}
type reportBytesPayload struct {
HasBytes *bool `json:"hasBytes"`
}
func classifySyncError(err error) (string, string) {
switch {
case errors.Is(err, repository.ErrNameConflict):
return "NAME_CONFLICT", "a resource with this name already exists here"
case errors.Is(err, repository.ErrNotFound):
return "NOT_FOUND", "target resource or folder not found"
case errors.Is(err, repository.ErrGranteeNotFound):
return "GRANTEE_NOT_FOUND", "the specified user does not exist"
case errors.Is(err, repository.ErrGroupNotFound):
return "GROUP_NOT_FOUND", "the specified group does not exist"
case errors.Is(err, repository.ErrPayloadMismatch):
return "INVALID_REQUEST", "operation replayed with different payload"
case errors.Is(err, errCycle):
return "INVALID_REQUEST", "cannot move a resource into its own subtree"
default:
// Volontairement générique : ne pas fuir SQL/FS internes (cf. #8).
// Le détail reste côté serveur (logs), le client reçoit un code stable.
log.Printf("sync: internal apply error: %v", err)
return "INVALID_REQUEST", "invalid operation"
}
}
var errCycle = errors.New("cannot move a resource into its own subtree")
// ApplyBatch applique les ops de l'outbox : les mutations de ressources sont
// scopées par l'UTILISATEUR (userID), l'idempotence reste par DEVICE
// (deviceID) — cf. docs/api-v1.md §6.1.
//
// Atomicité par op (#7) : chaque op est sérialisée par un claim atomique sur
// la trace outbox (INSERT ... ON CONFLICT DO NOTHING portant la contrainte
// UNIQUE(device_id, operation_id), cf. Operations.Claim) — deux batches
// concurrents ne peuvent pas appliquer deux fois la même op : le perdant
// suit le chemin rejeu (comparaison de hash, cf. A9). Le claim est posé en
// status='failed' AVANT l'apply puis promu en 'applied' (MarkApplied) une
// fois l'effet durable : un crash entre les deux laisse une trace rejouable
// (ré-apply à payload identique), jamais un skip silencieux.
//
// Limite documentée : claim→apply→promote ne sont pas une transaction SQL
// unique — apply touche resources/shares via des statements atomiques
// (INSERT ... SELECT parent, TouchOwned). Le TOCTOU résiduel (deux owners
// créant le même resource_id) dégénère en NAME_CONFLICT explicite, jamais
// en double écriture silencieuse. Une atomicité totale exigerait un
// transaction manager transverse aux repos (vrai Tx ApplyBatch, reportée —
// cf. FEEDBACK risques résiduels).
//
// Erreurs de persistance (claim/promote) : retournées comme applied:i
// explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client
// sait exactement où reprendre.
func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) {
for i := range ops {
op := &ops[i]
if err := validateSyncOp(op); err != nil {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil
}
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 {
// Faute client (clé ou payload malformé) → INVALID_REQUEST halt,
// message statique sûr ; panne persistance → INTERNAL explicite.
if errors.Is(err, repository.ErrInvalidOperationID) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation_id must be 32 lowercase hex chars"}}, nil
}
if errors.Is(err, repository.ErrInvalidPayload) {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil
}
log.Printf("sync: claim device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to persist operation state"}}, nil
}
if !claimed {
// Rejeu : même (device, op) déjà tracé — comparer (A9).
stored, err := s.Repository.Operations.Get(deviceID, op.OperationID)
if err != nil {
log.Printf("sync: replay read device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to read operation state"}}, nil
}
if err := stored.MatchesReplay(op.Operation, derefString(op.ResourceID), op.Payload); err != nil {
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation replayed with different payload"}}, nil
}
if stored.Status == repository.OpStatusApplied {
continue // déjà appliquée à l'identique → skip idempotent
}
// Trace 'failed' à payload identique : la première tentative est
// morte avant MarkApplied (crash) → on ré-applique (recovery).
}
if err := s.applySyncOp(userID, deviceID, op); err != nil {
code, message := classifySyncError(err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil
}
if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil {
log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err)
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "operation applied but trace update failed; safe to retry"}}, nil
}
}
return SyncResult{Applied: len(ops)}, nil
}
func validateSyncOp(op *SyncOperation) error {
if !resourceIDPattern.MatchString(op.OperationID) {
return errors.New("operation_id must be 32 lowercase hex chars")
}
if op.Operation == "" {
return errors.New("missing operation type")
}
if !resourceIDPattern.MatchString(derefString(op.ResourceID)) {
return errors.New("resource_id must be 32 lowercase hex chars")
}
switch op.Operation {
case OpCreateResource, OpUpdateMetadata, OpMoveResource, OpDeleteResource,
OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink,
OpReportBytes, OpTrashResource, OpRestoreResource, OpPurgeResource:
default:
return errors.New("unknown operation " + op.Operation)
}
if derefString(op.ResourceType) != "folder" && derefString(op.ResourceType) != "file" {
return errors.New("resource_type must be 'folder' or 'file'")
}
return nil
}
func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) error {
resourceID := derefString(op.ResourceID)
switch op.Operation {
case OpCreateResource:
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if exists {
return nil
}
var p createResourcePayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.Name == "" {
return errors.New("payload.name required")
}
// Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon,
// cohérent avec move_resource). Ordre du SAF walk : parent avant enfant.
if p.ParentResourceID != "" {
if !resourceIDPattern.MatchString(p.ParentResourceID) {
return errors.New("payload.parentResourceId must be 32 lowercase hex chars")
}
if _, err := s.Repo.GetFolder(ownerID, p.ParentResourceID); err != nil {
return err
}
}
var insertErr error
if derefString(op.ResourceType) == "folder" {
insertErr = s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID)
} else {
mime := p.MimeType
insertErr = s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension))
}
if insertErr != nil {
// Course ExistsOwner→Insert (concurrent ou rejeu croisé) : si la
// ressource est désormais owned, l'effet est atteint → idempotent.
// Sinon NAME_CONFLICT explicite (sibling ou resource_id d'autrui).
// Atomicité totale (INSERT ... SELECT) : inter-lots, LOT 4.
if errors.Is(insertErr, repository.ErrNameConflict) {
if owned, err := s.Repo.ExistsOwner(ownerID, resourceID); err == nil && owned {
return nil
}
}
return insertErr
}
return nil
case OpUpdateMetadata:
// Sémantique uniforme (A8) : toute ressource que l'appelant ne peut
// pas renommer — absente, d'autrui, ou partagée sous editor — halte
// en NOT_FOUND. Pas de no-op silencieux : un rename qui n'a rien
// renommé est un bug client ou une désync, le halt l'expose au lieu
// de valider un état qui n'existe pas. Le même code NOT_FOUND dans
// tous les cas évite tout oracle d'existence. Owner → rank owner,
// editor+ partagé → autorisé (docs §6.2).
access, err := s.Repository.Shares.EffectiveAccess(ownerID, resourceID)
if err != nil {
return err
}
if access.EffectiveRank < repository.AccessEditor {
return repository.ErrNotFound
}
var p renamePayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.Name == "" {
return errors.New("payload.name required")
}
// NOTE : UpdateNameByID (non-scopé) est volontaire ici — un editor
// non-owner peut renommer (EffectiveAccess vérifié plus haut), donc
// UpdateNameOwned(ownerID, ...) rejetterait à tort. La garde
// d'autorisation précède immédiatement l'écriture.
return s.Repo.UpdateNameByID(resourceID, p.Name)
case OpMoveResource:
// A8 : move owner-only. Source non-owned (absente OU d'autrui) →
// NOT_FOUND halt (MoveResource ne touche que les lignes owned).
// Pas de applied silencieux : un move qui n'a rien déplacé
// désynchroniserait le client.
var p movePayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.ToFolderResourceID == resourceID {
return errors.New("cannot move a resource into itself")
}
if p.ToFolderResourceID != "" {
if !resourceIDPattern.MatchString(p.ToFolderResourceID) {
return errors.New("payload.toFolderResourceId must be 32 lowercase hex chars")
}
// Check de cycle : le dossier cible ne doit pas être la ressource
// elle-même ni l'un de ses descendants (cf. FEEDBACK #2).
if err := s.checkNoCycle(p.ToFolderResourceID, resourceID); err != nil {
return err
}
}
return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID)
case OpDeleteResource, OpTrashResource:
// V3 : delete_resource (legacy) = trash_resource. A8 : owner-only.
// Ligne vivante d'autrui → NOT_FOUND halt (pas de applied
// silencieux). Aucune ligne (jamais existé, déjà trashée/purgée par
// 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)
if err != nil {
return err
}
if !exists {
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil
}
return err
}
return repository.ErrNotFound
}
return s.Repo.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:
return s.applyShareOp(ownerID, resourceID, op)
case OpRevokeShare:
return s.applyRevokeShareOp(ownerID, resourceID, op)
case OpCreateLink:
return s.applyCreateLinkOp(ownerID, resourceID, op)
case OpRevokeLink:
return s.applyRevokeLinkOp(ownerID, resourceID, op)
case OpReportBytes:
return s.applyReportBytesOp(ownerID, deviceID, resourceID, op)
default:
return errors.New("unknown operation " + op.Operation)
}
}
// applyReportBytesOp handles OpReportBytes: a device reports its byte
// presence (V2 placements). Scope is viewer+ (owned or shared,
// GetFileVisible) — a grantee downloading a shared file reports too.
// Invisible → ErrNotFound (no enumeration). Naturally idempotent ; the A9
// replay guard requires a FRESH operation_id per state change.
func (s *Resources) applyReportBytesOp(userID, deviceID, resourceID string, op *SyncOperation) error {
if derefString(op.ResourceType) != "file" {
return errors.New("resource_type must be 'file' for report_bytes")
}
if _, err := s.Repo.GetFileVisible(userID, resourceID); err != nil {
return err
}
var p reportBytesPayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.HasBytes == nil {
return errors.New("payload.hasBytes required")
}
return s.Repository.Placements.Report(userID, deviceID, resourceID, *p.HasBytes)
}
// applyShareOp handles OpShare and OpUpdateShare: upsert a user-to-user grant.
func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) error {
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if !exists {
return repository.ErrNotFound
}
var p sharePayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
// Cible : exactement un principal (user XOR groupe, V2-6).
isUser := p.GranteeUserID != ""
isGroup := p.GranteeGroupID != ""
if isUser == isGroup {
return errors.New("payload requires exactly one of granteeUserId, granteeGroupId")
}
if isUser && !resourceIDPattern.MatchString(p.GranteeUserID) {
return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
}
if isGroup && !resourceIDPattern.MatchString(p.GranteeGroupID) {
return errors.New("payload.granteeGroupId must be 32 lowercase hex chars")
}
rank := repository.AccessFromString(p.Access)
if rank < repository.AccessViewer || rank > repository.AccessEditor {
return errors.New("payload.access must be viewer, commenter, or editor")
}
inherit := true
if p.Inherit != nil {
inherit = *p.Inherit
}
var expiresAt *time.Time
if p.ExpiresAt != nil {
t := time.UnixMilli(*p.ExpiresAt)
if !t.After(time.Now()) {
return errors.New("payload.expiresAt must be in the future")
}
expiresAt = &t
}
if isUser {
// Validate grantee exists and is active.
if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
}
} else {
// Validate group exists (any group : ids are unguessable, no enum).
if _, err := s.Repository.Groups.Get(p.GranteeGroupID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGroupNotFound
}
return err
}
if err := s.Repository.Shares.UpsertGroup(resourceID, p.GranteeGroupID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
}
}
// Bump resource updated_at so the grantee's delta snapshot picks it up.
// Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le
// TouchResource non-scopé.
return s.Repo.TouchOwned(ownerID, resourceID)
}
// applyRevokeShareOp handles OpRevokeShare: soft-revoke a user-to-user grant.
func (s *Resources) applyRevokeShareOp(ownerID, resourceID string, op *SyncOperation) error {
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if !exists {
return repository.ErrNotFound
}
var p revokeSharePayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.GranteeUserID == "" {
return errors.New("payload.granteeUserId required")
}
if !resourceIDPattern.MatchString(p.GranteeUserID) {
return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
}
// Revoke is idempotent: no-op if already revoked/missing — mais les vraies
// pannes DB remontent (cf. FEEDBACK §moyenne).
if err := s.Repository.Shares.Revoke(resourceID, p.GranteeUserID); err != nil && !errors.Is(err, repository.ErrNotFound) {
return err
}
// Bump resource updated_at so the grantee's delta snapshot reflects the change.
return s.Repo.TouchOwned(ownerID, resourceID)
}
// applyCreateLinkOp handles OpCreateLink: create a public share link.
func (s *Resources) applyCreateLinkOp(ownerID, resourceID string, op *SyncOperation) error {
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if !exists {
return repository.ErrNotFound
}
var p linkPayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if !resourceIDPattern.MatchString(p.Token) {
return errors.New("payload.token must be 32 lowercase hex chars")
}
rank := repository.AccessFromString(p.Access)
if rank < repository.AccessViewer || rank > repository.AccessEditor {
return errors.New("payload.access must be viewer, commenter, or editor")
}
var expiresAt *time.Time
if p.ExpiresAt != nil {
t := time.UnixMilli(*p.ExpiresAt)
if !t.After(time.Now()) {
return errors.New("payload.expiresAt must be in the future")
}
expiresAt = &t
}
if err := s.Repository.Shares.CreateLink(p.Token, resourceID, p.Access, expiresAt, ownerID); err != nil {
return err
}
return s.Repo.TouchOwned(ownerID, resourceID)
}
// applyRevokeLinkOp handles OpRevokeLink: soft-revoke a public share link.
func (s *Resources) applyRevokeLinkOp(ownerID, resourceID string, op *SyncOperation) error {
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
if err != nil {
return err
}
if !exists {
return repository.ErrNotFound
}
var p revokeLinkPayload
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if !resourceIDPattern.MatchString(p.Token) {
return errors.New("payload.token must be 32 lowercase hex chars")
}
// Revoke is idempotent: no-op if already revoked/missing — mais les vraies
// pannes DB remontent.
if err := s.Repository.Shares.RevokeLink(p.Token); err != nil && !errors.Is(err, repository.ErrNotFound) {
return err
}
return s.Repo.TouchOwned(ownerID, resourceID)
}
// checkNoCycle remonte la chaîne parentale depuis toFolder : si on rencontre
// resourceID, le move créerait un cycle (cf. FEEDBACK #2).
func (s *Resources) checkNoCycle(toFolderID, resourceID string) error {
cur := toFolderID
for i := 0; i < 128; i++ {
if cur == "" {
return nil
}
if cur == resourceID {
return errCycle
}
parent, err := s.Repo.GetParentID(cur)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return err
}
return err
}
cur = parent
}
return errCycle
}
func derefString(v *string) string {
if v == nil {
return ""
}
return *v
}
func derefInt64(v *int64) int64 {
if v == nil {
return 0
}
return *v
}
func nullableString(value string) *string {
if value == "" {
return nil
}
return &value
}
func nullableInt64(value int64) *int64 {
if value == 0 {
return nil
}
return &value
}
// ResourcePermission is the snapshot shape consumed by canAccess
// (docs/api-v1.md §6.2).
type ResourcePermission struct {
ResourceID string `json:"resource_id"`
ResourceType string `json:"resourceType"`
EffectiveAccess string `json:"effectiveAccess"`
Name string `json:"name"`
ParentID *string `json:"parentId"`
Inherit bool `json:"inherit"`
OwnerID string `json:"ownerId"`
SharedByID *string `json:"sharedById"`
ExpiresAt *int64 `json:"expiresAt"`
CachedAt int64 `json:"cachedAt"`
UpdatedAt int64 `json:"updatedAt"`
}
// Snapshot returns the delta of effective permissions for the user since
// afterMs (epoch ms; 0 = all). Uses the recursive CTE computed by
// repository.Shares.ListEffectivePermissions.
func (s *Resources) Snapshot(ownerID string, afterMs int64) ([]ResourcePermission, error) {
perms, err := s.Repository.Shares.ListEffectivePermissions(ownerID, afterMs)
if err != nil {
return nil, err
}
now := time.Now().UnixMilli()
out := make([]ResourcePermission, 0, len(perms))
for _, p := range perms {
rp := ResourcePermission{
ResourceID: p.ResourceID,
ResourceType: p.ResourceType,
EffectiveAccess: repository.AccessToString(p.EffectiveRank),
Name: p.Name,
ParentID: p.ParentID,
Inherit: p.Inherit,
OwnerID: p.OwnerID,
SharedByID: p.SharedByID,
CachedAt: now,
UpdatedAt: p.UpdatedAt.UnixMilli(),
}
if p.ExpiresAt != nil {
ms := p.ExpiresAt.UnixMilli()
rp.ExpiresAt = &ms
}
out = append(out, rp)
}
return out, nil
}