fix backend audit findings (auth, upload, sync, data, ocr, contract)
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
This commit is contained in:
@@ -1,7 +1,9 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"regexp"
|
||||
@@ -16,9 +18,26 @@ type Operations struct {
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
// Statuts de la trace outbox (CHECK status IN ('applied','failed'), 000004).
|
||||
// 'failed' = brouillon claimé pas encore confirmé (ou apply en échec) ;
|
||||
// 'applied' = effet durable confirmé.
|
||||
const (
|
||||
OpStatusApplied = "applied"
|
||||
OpStatusFailed = "failed"
|
||||
)
|
||||
|
||||
// ErrInvalidOperationID is returned when operation_id is not 32 lowercase hex.
|
||||
var ErrInvalidOperationID = errors.New("operation_id must be 32 lowercase hex chars")
|
||||
|
||||
// ErrInvalidPayload is returned when the trace payload is not valid JSON.
|
||||
// Le service le mappe en INVALID_REQUEST (faute client, message statique sûr).
|
||||
var ErrInvalidPayload = errors.New("invalid payload JSON")
|
||||
|
||||
// ErrPayloadMismatch is returned when an operation is replayed under the same
|
||||
// (device_id, operation_id) with a different payload (cf. A9). The replay
|
||||
// must halt in INVALID_REQUEST, never skip silently.
|
||||
var ErrPayloadMismatch = errors.New("operation replayed with different payload")
|
||||
|
||||
// Applied reports whether the operation was already processed for this device.
|
||||
func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
|
||||
var exists int
|
||||
@@ -32,20 +51,157 @@ func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
|
||||
return err == nil, err
|
||||
}
|
||||
|
||||
// StoredOp is the persisted trace of an applied operation (replay compare).
|
||||
type StoredOp struct {
|
||||
OpType string
|
||||
ResourceID string
|
||||
Payload []byte
|
||||
Status string
|
||||
PayloadHash string // "" = trace héritée pré-000013 (hash recalculé depuis Payload)
|
||||
}
|
||||
|
||||
// Get returns the stored trace for (device, operation), or sql.ErrNoRows.
|
||||
func (o *Operations) Get(deviceID, operationID string) (StoredOp, error) {
|
||||
var op StoredOp
|
||||
var resourceID sql.NullString
|
||||
var payloadHash sql.NullString
|
||||
var payload []byte
|
||||
err := o.DB.QueryRow(
|
||||
`SELECT op_type, resource_id, COALESCE(payload::text, '{}'), status, payload_hash
|
||||
FROM operations WHERE device_id = $1 AND operation_id = $2`,
|
||||
deviceID, operationID,
|
||||
).Scan(&op.OpType, &resourceID, &payload, &op.Status, &payloadHash)
|
||||
if err != nil {
|
||||
return StoredOp{}, err
|
||||
}
|
||||
if resourceID.Valid {
|
||||
op.ResourceID = resourceID.String
|
||||
}
|
||||
if payloadHash.Valid {
|
||||
op.PayloadHash = payloadHash.String
|
||||
}
|
||||
op.Payload = payload
|
||||
return op, nil
|
||||
}
|
||||
|
||||
// Claim atomically takes ownership of an operation slot for this device
|
||||
// (#7 : sérialisation des batches concurrents sur la contrainte
|
||||
// UNIQUE(device_id, operation_id)). Premier appelant → claimed=true, la ligne
|
||||
// est insérée en status='failed' (brouillon) avec le hash du payload ; le
|
||||
// perdant du conflit (claimed=false) suit le chemin rejeu (comparer via Get).
|
||||
// Après apply réussi, l'appelant promeut la ligne via MarkApplied ; en cas
|
||||
// d'échec d'apply, la ligne reste 'failed' (rejouable à payload identique).
|
||||
func (o *Operations) Claim(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) (bool, error) {
|
||||
if !operationIDPattern.MatchString(operationID) {
|
||||
return false, ErrInvalidOperationID
|
||||
}
|
||||
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
|
||||
return false, ErrInvalidPayload
|
||||
}
|
||||
var refTypeValue any
|
||||
if refType != "" {
|
||||
refTypeValue = refType
|
||||
}
|
||||
res, err := o.DB.Exec(
|
||||
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'failed')
|
||||
ON CONFLICT (device_id, operation_id) DO NOTHING`,
|
||||
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload),
|
||||
)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return affected == 1, nil
|
||||
}
|
||||
|
||||
// MarkApplied promotes a claimed ('failed') trace row to 'applied' once the
|
||||
// operation effect is durable. Best-effort : l'échec est remonté pour que le
|
||||
// batch retourne applied:i explicite (rejouable, pas 500 nu).
|
||||
func (o *Operations) MarkApplied(deviceID, operationID string) error {
|
||||
res, err := o.DB.Exec(
|
||||
`UPDATE operations SET status = 'applied'
|
||||
WHERE device_id = $1 AND operation_id = $2 AND status = 'failed'`,
|
||||
deviceID, operationID,
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
// Déjà promue (rejeu concurrent) ou ligne absente : pas d'erreur,
|
||||
// l'idempotence est portée par la contrainte d'unicité.
|
||||
return nil
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// MatchesReplay reports whether an incoming operation matches the stored
|
||||
// trace: same op type, same resource, same canonical payload hash. Legacy
|
||||
// rows (payload_hash NULL, pré-000013) comparent le hash recalculé depuis le
|
||||
// payload stocké. Mismatch → ErrPayloadMismatch (wrappable via errors.Is).
|
||||
func (op StoredOp) MatchesReplay(opType, resourceID string, payload []byte) error {
|
||||
if op.OpType != opType || op.ResourceID != resourceID {
|
||||
return ErrPayloadMismatch
|
||||
}
|
||||
want := CanonicalPayloadHash(payload)
|
||||
got := op.PayloadHash
|
||||
if got == "" {
|
||||
got = CanonicalPayloadHash(op.Payload)
|
||||
}
|
||||
if got != want {
|
||||
return ErrPayloadMismatch
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanonicalPayloadHash is sha256-hex of the canonical payload form: empty /
|
||||
// "null" → {}, sinon round-trip JSON (clés triées, espaces neutralisés) pour
|
||||
// que deux sérialisations du même objet donnent le même hash.
|
||||
func CanonicalPayloadHash(payload []byte) string {
|
||||
sum := sha256.Sum256(canonicalPayloadBytes(payload))
|
||||
return hex.EncodeToString(sum[:])
|
||||
}
|
||||
|
||||
func canonicalPayloadBytes(payload []byte) []byte {
|
||||
if len(payload) == 0 || string(payload) == "null" {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
var v any
|
||||
if err := json.Unmarshal(payload, &v); err != nil {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
out, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// Record stores an applied operation trace (idempotent on replay).
|
||||
// Le hash canonique du payload est persisté (000013, cf. A9) ; status='applied'.
|
||||
func (o *Operations) Record(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) error {
|
||||
if !operationIDPattern.MatchString(operationID) {
|
||||
return ErrInvalidOperationID
|
||||
}
|
||||
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
|
||||
return ErrInvalidPayload
|
||||
}
|
||||
var refTypeValue any
|
||||
if refType != "" {
|
||||
refTypeValue = refType
|
||||
}
|
||||
_, err := o.DB.Exec(
|
||||
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
||||
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'applied')
|
||||
ON CONFLICT (device_id, operation_id) DO NOTHING`,
|
||||
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload),
|
||||
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload),
|
||||
)
|
||||
return err
|
||||
}
|
||||
@@ -62,7 +218,9 @@ func jsonBytes(payload []byte) any {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
if !json.Valid(payload) {
|
||||
return []byte(`{}`)
|
||||
// Trace infidèle refusée (cf. A15) : l'appelant doit rejeter en amont ;
|
||||
// ici on ne normalise plus silencieusement vers {}.
|
||||
return nil
|
||||
}
|
||||
return payload
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user