gtsocial-umbx

serialize.go (6510B)

---

 // GoToSocial
 // Copyright (C) GoToSocial Authors admin@gotosocial.org
 // SPDX-License-Identifier: AGPL-3.0-or-later
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU Affero General Public License for more details.
 //
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 package ap
 
 import (
 	"fmt"
 
 	"github.com/superseriousbusiness/activity/streams"
 	"github.com/superseriousbusiness/activity/streams/vocab"
 )
 
 // Serialize is a custom serializer for ActivityStreams types.
 //
 // In most cases, it will simply call the go-fed streams.Serialize function under the hood.
 // However, if custom serialization is required on a specific type (eg for inter-implementation
 // compatibility), it can be inserted into the switch as necessary.
 //
 // Callers should always call this function instead of streams.Serialize, unless there's a
 // very good reason to do otherwise.
 //
 // Currently, the following things will be custom serialized:
 //
 //   - OrderedCollection: 'orderedItems' property will always be made into an array.
 //   - Any Accountable type: 'attachment' property will always be made into an array.
 //   - Update: any Accountable 'object's set on an update will be custom serialized as above.
 func Serialize(t vocab.Type) (m map[string]interface{}, e error) {
 	switch t.GetTypeName() {
 	case ObjectOrderedCollection:
 		return serializeOrderedCollection(t)
 	case ActorApplication, ActorGroup, ActorOrganization, ActorPerson, ActorService:
 		return serializeAccountable(t, true)
 	case ActivityUpdate:
 		return serializeWithObject(t)
 	default:
 		// No custom serializer necessary.
 		return streams.Serialize(t)
 	}
 }
 
 // serializeOrderedCollection is a custom serializer for an ActivityStreamsOrderedCollection.
 // Unlike the standard streams.Serialize function, this serializer normalizes the orderedItems
 // value to always be an array/slice, regardless of how many items are contained therein.
 //
 // TODO: Remove this function if we can fix the underlying issue in Go-Fed.
 //
 // See:
 //   - https://github.com/go-fed/activity/issues/139
 //   - https://github.com/mastodon/mastodon/issues/24225
 func serializeOrderedCollection(orderedCollection vocab.Type) (map[string]interface{}, error) {
 	data, err := streams.Serialize(orderedCollection)
 	if err != nil {
 		return nil, err
 	}
 
 	orderedItems, ok := data["orderedItems"]
 	if !ok {
 		// No 'orderedItems', nothing to change.
 		return data, nil
 	}
 
 	if _, ok := orderedItems.([]interface{}); ok {
 		// Already slice.
 		return data, nil
 	}
 
 	// Coerce single-object to slice.
 	data["orderedItems"] = []interface{}{orderedItems}
 
 	return data, nil
 }
 
 // SerializeAccountable is a custom serializer for any Accountable type.
 // This serializer rewrites the 'attachment' value of the Accountable, if
 // present, to always be an array/slice.
 //
 // While this is not strictly necessary in json-ld terms, most other fedi
 // implementations look for attachment to be an array of PropertyValue (field)
 // entries, and will not parse single-entry, non-array attachments on accounts
 // properly.
 //
 // If the accountable is being serialized as a top-level object (eg., for serving
 // in response to an account dereference request), then includeContext should be
 // set to true, so as to include the json-ld '@context' entries in the data.
 // If the accountable is being serialized as part of another object (eg., as the
 // object of an activity), then includeContext should be set to false, as the
 // @context entry should be included on the top-level/wrapping activity/object.
 func serializeAccountable(accountable vocab.Type, includeContext bool) (map[string]interface{}, error) {
 	var (
 		data map[string]interface{}
 		err  error
 	)
 
 	if includeContext {
 		data, err = streams.Serialize(accountable)
 	} else {
 		data, err = accountable.Serialize()
 	}
 
 	if err != nil {
 		return nil, err
 	}
 
 	attachment, ok := data["attachment"]
 	if !ok {
 		// No 'attachment', nothing to change.
 		return data, nil
 	}
 
 	if _, ok := attachment.([]interface{}); ok {
 		// Already slice.
 		return data, nil
 	}
 
 	// Coerce single-object to slice.
 	data["attachment"] = []interface{}{attachment}
 
 	return data, nil
 }
 
 func serializeWithObject(t vocab.Type) (map[string]interface{}, error) {
 	withObject, ok := t.(WithObject)
 	if !ok {
 		return nil, fmt.Errorf("serializeWithObject: could not resolve %T to WithObject", t)
 	}
 
 	data, err := streams.Serialize(t)
 	if err != nil {
 		return nil, err
 	}
 
 	object := withObject.GetActivityStreamsObject()
 	if object == nil {
 		// Nothing to do, bail early.
 		return data, nil
 	}
 
 	objectLen := object.Len()
 	if objectLen == 0 {
 		// Nothing to do, bail early.
 		return data, nil
 	}
 
 	// The thing we already serialized has objects
 	// on it, so we should see if we need to custom
 	// serialize any of those objects, and replace
 	// them on the data map as necessary.
 	objects := make([]interface{}, 0, objectLen)
 	for iter := object.Begin(); iter != object.End(); iter = iter.Next() {
 		if iter.IsIRI() {
 			// Plain IRIs don't need custom serialization.
 			objects = append(objects, iter.GetIRI().String())
 			continue
 		}
 
 		var (
 			objectType = iter.GetType()
 			objectSer  map[string]interface{}
 		)
 
 		if objectType == nil {
 			// This is awkward.
 			return nil, fmt.Errorf("serializeWithObject: could not resolve object iter %T to vocab.Type", iter)
 		}
 
 		switch objectType.GetTypeName() {
 		case ActorApplication, ActorGroup, ActorOrganization, ActorPerson, ActorService:
 			// @context will be included in wrapping type already,
 			// we don't need to include it in the object itself.
 			objectSer, err = serializeAccountable(objectType, false)
 		default:
 			// No custom serializer for this type; serialize as normal.
 			objectSer, err = objectType.Serialize()
 		}
 
 		if err != nil {
 			return nil, err
 		}
 
 		objects = append(objects, objectSer)
 	}
 
 	if objectLen == 1 {
 		// Unnest single object.
 		data["object"] = objects[0]
 	} else {
 		// Array of objects.
 		data["object"] = objects
 	}
 
 	return data, nil
 }