package store import ( "encoding/json" "github.com/google/uuid" ) // ObjectDeletionSnapshot proves the full current binding set belongs to one // Domain. It is issued by the store, not accepted as client-provided metadata. // Each Path still needs the caller's delete grant; one allowed alias is never // sufficient authority to destroy an Object through all its other aliases. type ObjectDeletionSnapshot struct { domainUUID string objectUUID string bindings []pathRename } func (snapshot *ObjectDeletionSnapshot) Paths() []string { paths := make([]string, len(snapshot.bindings)) for i, binding := range snapshot.bindings { paths[i] = binding.OldPath } return paths } func objectDeletionBindings(q pathQueryer, domainUUID, objectUUID string) ([]pathRename, error) { rows, err := q.Query(`SELECT domain_uuid, path, object_uuid, created_at, COALESCE(is_primary,0) FROM paths WHERE object_uuid=? AND EXISTS(SELECT 1 FROM objects WHERE uuid=?) ORDER BY domain_uuid, path COLLATE BINARY LIMIT ?`, objectUUID, objectUUID, MaxPathMutationPaths+1) if err != nil { return nil, err } defer rows.Close() var bindings []pathRename for rows.Next() { var binding pathRename var bindingDomain string if err := rows.Scan(&bindingDomain, &binding.OldPath, &binding.ObjectUUID, &binding.CreatedAt, &binding.IsPrimary); err != nil { return nil, err } if bindingDomain != domainUUID { return nil, ErrAccessDenied } bindings = append(bindings, binding) } if err := rows.Err(); err != nil { return nil, err } if len(bindings) == 0 { // Objects do not have an owner Domain column. Without any binding the // current Domain cannot prove authority, including for an administrator. return nil, ErrAccessDenied } if len(bindings) > MaxPathMutationPaths { return nil, ErrPathMutationTooLarge } return bindings, nil } func (s *Store) SnapshotObjectDeletionInDomain(domainUUID, objectUUID string) (*ObjectDeletionSnapshot, error) { bindings, err := objectDeletionBindings(s.DB, domainUUID, objectUUID) if err != nil { return nil, err } return &ObjectDeletionSnapshot{domainUUID: domainUUID, objectUUID: objectUUID, bindings: bindings}, nil } // DeleteObjectInDomainChecked is a purge, not an unlink. It rejects shared and // unbound Objects and revalidates every authorized binding in the same // transaction as the Object/Revision deletion. The global DeleteObject API is // retained solely for trusted local administrative code. func (s *Store) DeleteObjectInDomainChecked(domainUUID, objectUUID string, snapshot *ObjectDeletionSnapshot) error { if snapshot == nil || snapshot.domainUUID != domainUUID || snapshot.objectUUID != objectUUID || len(snapshot.bindings) == 0 { return ErrPathSnapshotChanged } if err := s.ensureLocalDomain(domainUUID); err != nil { return err } tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() bindings, err := objectDeletionBindings(tx, domainUUID, objectUUID) if err == ErrAccessDenied { return ErrPathSnapshotChanged } if err != nil { return err } if len(bindings) != len(snapshot.bindings) { return ErrPathSnapshotChanged } for i, binding := range bindings { if snapshot.bindings[i] != binding { return ErrPathSnapshotChanged } } if err := deleteObjectTx(tx, objectUUID); err != nil { return pathMutationTransactionError(err) } operationID := uuid.NewString() payload, err := json.Marshal(map[string]any{"operation_uuid": operationID, "object_uuid": objectUUID, "count": len(bindings)}) if err != nil { return err } if err := s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{ DomainUUID: domainUUID, EventType: "object.deleted", TargetKind: "object", TargetUUID: objectUUID, Payload: string(payload), IdempotencyKey: "object.deleted:" + operationID, }); err != nil { return err } if err := tx.Commit(); err != nil { return pathMutationTransactionError(err) } s.InvalidatePathCaches() return nil }