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" ) // 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"` 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.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: 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: // A8 : delete owner-only. Ligne vivante d'autrui → NOT_FOUND halt // (pas de applied silencieux). Aucune ligne vivante (jamais existé, // ou déjà supprimée par son owner) → no-op idempotent : l'état // terminal (absente) est déjà atteint, le rejeu reste sûr. exists, err := s.Repo.ExistsOwner(ownerID, resourceID) if err != nil { return err } if !exists { if _, err := s.Repo.GetResourceOwner(resourceID); err != nil { if errors.Is(err, repository.ErrNotFound) { return nil } return err } return repository.ErrNotFound } return s.Repo.SyncDelete(ownerID, resourceID) case OpShare, OpUpdateShare: 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()) } 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") } rank := repository.AccessFromString(p.Access) if rank < repository.AccessViewer || rank > repository.AccessEditor { return errors.New("payload.access must be viewer, commenter, or editor") } // Validate grantee exists and is active. if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil { if errors.Is(err, repository.ErrNotFound) { return repository.ErrGranteeNotFound } return err } inherit := true if p.Inherit != nil { inherit = *p.Inherit } 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.Upsert(resourceID, p.GranteeUserID, 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 }