refactor & enhance AP elements used (#7728)

This PR is part of https://codeberg.org/forgejo/forgejo/pulls/4767 filed by @algernon

To keep changes isolated this might be reviewed &  merge after https://codeberg.org/forgejo/forgejo/pulls/7714

Refactor existing code to have one AP struct per file.
Enhance AP structs needed by related PR

## Checklist

The [contributor guide](https://forgejo.org/docs/next/contributor/) contains information that will be helpful to first time contributors. There also are a few [conditions for merging Pull Requests in Forgejo repositories](https://codeberg.org/forgejo/governance/src/branch/main/PullRequestsAgreement.md). You are also welcome to join the [Forgejo development chatroom](https://matrix.to/#/#forgejo-development:matrix.org).

### Tests

- I added test coverage for Go changes...
  - [x] in their respective `*_test.go` for unit tests.

### Release notes

- [x] I do not want this change to show in the release notes.
- [ ] I want the title to show in the release notes with a link to this pull request.
- [ ] I want the content of the `release-notes/<pull request number>.md` to be be used for the release notes instead of the title.

Co-authored-by: zam <mirco.zachmann@meissa.de>
Co-authored-by: Mirco Zachmann <nostar@noreply.codeberg.org>
Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/7728
Reviewed-by: Earl Warren <earl-warren@noreply.codeberg.org>
Co-authored-by: Michael Jerger <michael.jerger@meissa-gmbh.de>
Co-committed-by: Michael Jerger <michael.jerger@meissa-gmbh.de>

.deadcode-out

@@ -87,12 +87,24 @@ forgejo.org/modules/eventsource
 	Event.String
 
 forgejo.org/modules/forgefed
+	NewForgeFollowFromAp
+	NewForgeFollow
+	ForgeFollow.MarshalJSON
+	ForgeFollow.UnmarshalJSON
+	ForgeFollow.Validate
 	NewForgeUndoLike
 	ForgeUndoLike.UnmarshalJSON
 	ForgeUndoLike.Validate
+	NewForgeUserActivityFromAp
+	NewForgeUserActivity
+	ForgeUserActivity.Validate
+	NewPersonIDFromModel
 	GetItemByType
 	JSONUnmarshalerFn
 	NotEmpty
+	NewForgeUserActivityNoteFromAp
+	newNote
+	ForgeUserActivityNote.Validate
 	ToRepository
 	OnRepository
 

modules/forgefed/activity_follow.go

@@ -0,0 +1,57 @@
+// Copyright 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+	"github.com/google/uuid"
+)
+
+// ForgeFollow activity data type
+// swagger:model
+type ForgeFollow struct {
+	// swagger:ignore
+	ap.Activity
+}
+
+func NewForgeFollowFromAp(activity ap.Activity) (ForgeFollow, error) {
+	result := ForgeFollow{}
+	result.Activity = activity
+	if valid, err := validation.IsValid(result); !valid {
+		return ForgeFollow{}, err
+	}
+	return result, nil
+}
+
+func NewForgeFollow(actor, object string) (ForgeFollow, error) {
+	result := ForgeFollow{}
+	result.Type = ap.FollowType
+	result.ID = ap.IRI(actor + "/follows/" + uuid.New().String())
+	result.Actor = ap.IRI(actor)
+	result.Object = ap.IRI(object)
+	if valid, err := validation.IsValid(result); !valid {
+		return ForgeFollow{}, err
+	}
+	return result, nil
+}
+
+func (follow ForgeFollow) MarshalJSON() ([]byte, error) {
+	return follow.Activity.MarshalJSON()
+}
+
+func (follow *ForgeFollow) UnmarshalJSON(data []byte) error {
+	return follow.Activity.UnmarshalJSON(data)
+}
+
+func (follow ForgeFollow) Validate() []string {
+	var result []string
+	result = append(result, validation.ValidateNotEmpty(string(follow.Type), "type")...)
+	result = append(result, validation.ValidateOneOf(string(follow.Type), []any{"Follow"}, "type")...)
+	result = append(result, validation.ValidateIDExists(follow.Actor, "actor")...)
+	result = append(result, validation.ValidateIDExists(follow.Object, "object")...)
+
+	return result
+}

modules/forgefed/activity_follow_test.go

@@ -0,0 +1,31 @@
+// Copyright 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"testing"
+
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+)
+
+func Test_NewForgeFollowValidation(t *testing.T) {
+	sut := ForgeFollow{}
+	sut.Type = "Follow"
+	sut.Actor = ap.IRI("example.org/alice")
+	sut.Object = ap.IRI("example.org/bob")
+
+	if err, _ := validation.IsValid(sut); !err {
+		t.Errorf("sut is invalid: %v\n", err)
+	}
+
+	sut = ForgeFollow{}
+	sut.Actor = ap.IRI("example.org/alice")
+	sut.Object = ap.IRI("example.org/bob")
+
+	if err, _ := validation.IsValid(sut); err {
+		t.Errorf("sut is valid: %v\n", err)
+	}
+}

modules/forgefed/activity_user_activity.go

@@ -0,0 +1,77 @@
+// Copyright 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"fmt"
+	"time"
+
+	user_model "forgejo.org/models/user"
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+)
+
+// ForgeFollow activity data type
+// swagger:model
+type ForgeUserActivity struct {
+	ap.Activity
+	Note ForgeUserActivityNote
+}
+
+func NewForgeUserActivityFromAp(activity ap.Activity) (ForgeUserActivity, error) {
+	result := ForgeUserActivity{}
+	result.Activity = activity
+	note, err := NewForgeUserActivityNoteFromAp(activity.Object)
+	if err != nil {
+		return ForgeUserActivity{}, err
+	}
+	result.Note = note
+	if valid, err := validation.IsValid(result); !valid {
+		return ForgeUserActivity{}, err
+	}
+	return result, nil
+}
+
+func NewForgeUserActivity(doer *user_model.User, actionID int64, content string) (ForgeUserActivity, error) {
+	id := fmt.Sprintf("%s/activities/%d", doer.APActorID(), actionID)
+	published := time.Now()
+
+	result := ForgeUserActivity{}
+	result.ID = ap.IRI(id + "/activity")
+	result.Type = ap.CreateType
+	result.Actor = ap.IRI(doer.APActorID())
+	result.Published = published
+	result.To = ap.ItemCollection{
+		ap.IRI("https://www.w3.org/ns/activitystreams#Public"),
+	}
+	result.CC = ap.ItemCollection{
+		ap.IRI(doer.APActorID() + "/followers"),
+	}
+	note, err := newNote(doer, content, id, published)
+	if err != nil {
+		return ForgeUserActivity{}, err
+	}
+	result.Object = note
+
+	return result, nil
+}
+
+func (userActivity ForgeUserActivity) Validate() []string {
+	var result []string
+	result = append(result, validation.ValidateNotEmpty(string(userActivity.Type), "type")...)
+	result = append(result, validation.ValidateOneOf(string(userActivity.Type), []any{"Create"}, "type")...)
+	result = append(result, validation.ValidateIDExists(userActivity.Actor, "actor")...)
+
+	if len(userActivity.To) == 0 {
+		result = append(result, "Missing to")
+	}
+	if len(userActivity.CC) == 0 {
+		result = append(result, "Missing cc")
+	}
+
+	result = append(result, userActivity.Note.Validate()...)
+
+	return result
+}

modules/forgefed/activity_user_activity_test.go

@@ -0,0 +1,40 @@
+// Copyright 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"testing"
+
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+)
+
+func Test_ForgeUserActivityValidation(t *testing.T) {
+	note := ForgeUserActivityNote{}
+	note.Type = "Note"
+	note.Content = ap.NaturalLanguageValues{
+		{
+			Ref:   ap.NilLangRef,
+			Value: ap.Content("Any Content!"),
+		},
+	}
+	note.URL = ap.IRI("example.org/user-id/57")
+
+	sut := ForgeUserActivity{}
+	sut.Type = "Create"
+	sut.Actor = ap.IRI("example.org/user-id/23")
+	sut.CC = ap.ItemCollection{
+		ap.IRI("example.org/registration/public#2nd"),
+	}
+	sut.To = ap.ItemCollection{
+		ap.IRI("example.org/registration/public"),
+	}
+
+	sut.Note = note
+
+	if res, _ := validation.IsValid(sut); !res {
+		t.Errorf("sut expected to be valid: %v\n", sut.Validate())
+	}
+}

modules/forgefed/actor.go

@@ -10,8 +10,6 @@ import (
 	"strings"
 
 	"forgejo.org/modules/validation"
-
-	ap "github.com/go-ap/activitypub"
 )
 
 // ----------------------------- ActorID --------------------------------------------
@@ -41,12 +39,18 @@ func NewActorID(uri string) (ActorID, error) {
 }
 
 func (id ActorID) AsURI() string {
-	var result string
+	var result, path string
+
+	if id.Path == "" {
+		path = id.ID
+	} else {
+		path = fmt.Sprintf("%s/%s", id.Path, id.ID)
+	}
 
 	if id.IsPortSupplemented {
-		result = fmt.Sprintf("%s://%s/%s/%s", id.HostSchema, id.Host, id.Path, id.ID)
+		result = fmt.Sprintf("%s://%s/%s", id.HostSchema, id.Host, path)
 	} else {
-		result = fmt.Sprintf("%s://%s:%d/%s/%s", id.HostSchema, id.Host, id.HostPort, id.Path, id.ID)
+		result = fmt.Sprintf("%s://%s:%d/%s", id.HostSchema, id.Host, id.HostPort, path)
 	}
 
 	return result
@@ -54,8 +58,7 @@ func (id ActorID) AsURI() string {
 
 func (id ActorID) Validate() []string {
 	var result []string
-	result = append(result, validation.ValidateNotEmpty(id.ID, "userId")...)
+	result = append(result, validation.ValidateNotEmpty(id.ID, "ID")...)
-	result = append(result, validation.ValidateNotEmpty(id.Path, "path")...)
 	result = append(result, validation.ValidateNotEmpty(id.Host, "host")...)
 	result = append(result, validation.ValidateNotEmpty(id.HostPort, "hostPort")...)
 	result = append(result, validation.ValidateNotEmpty(id.HostSchema, "hostSchema")...)
@@ -68,115 +71,6 @@ func (id ActorID) Validate() []string {
 	return result
 }
 
-// ----------------------------- PersonID --------------------------------------------
-type PersonID struct {
-	ActorID
-}
-
-// Factory function for PersonID. Created struct is asserted to be valid
-func NewPersonID(uri, source string) (PersonID, error) {
-	result, err := newActorID(uri)
-	if err != nil {
-		return PersonID{}, err
-	}
-	result.Source = source
-
-	// validate Person specific path
-	personID := PersonID{result}
-	if valid, err := validation.IsValid(personID); !valid {
-		return PersonID{}, err
-	}
-
-	return personID, nil
-}
-
-func (id PersonID) AsWebfinger() string {
-	result := fmt.Sprintf("@%s@%s", strings.ToLower(id.ID), strings.ToLower(id.Host))
-	return result
-}
-
-func (id PersonID) AsLoginName() string {
-	result := fmt.Sprintf("%s%s", strings.ToLower(id.ID), id.HostSuffix())
-	return result
-}
-
-func (id PersonID) HostSuffix() string {
-	result := fmt.Sprintf("-%s", strings.ToLower(id.Host))
-	return result
-}
-
-func (id PersonID) Validate() []string {
-	result := id.ActorID.Validate()
-	result = append(result, validation.ValidateNotEmpty(id.Source, "source")...)
-	result = append(result, validation.ValidateOneOf(id.Source, []any{"forgejo", "gitea"}, "Source")...)
-
-	switch id.Source {
-	case "forgejo", "gitea":
-		if strings.ToLower(id.Path) != "api/v1/activitypub/user-id" && strings.ToLower(id.Path) != "api/activitypub/user-id" {
-			result = append(result, fmt.Sprintf("path: %q has to be a person specific api path", id.Path))
-		}
-	}
-
-	return result
-}
-
-// ----------------------------- RepositoryID --------------------------------------------
-
-type RepositoryID struct {
-	ActorID
-}
-
-// Factory function for RepositoryID. Created struct is asserted to be valid.
-func NewRepositoryID(uri, source string) (RepositoryID, error) {
-	result, err := newActorID(uri)
-	if err != nil {
-		return RepositoryID{}, err
-	}
-	result.Source = source
-
-	// validate Person specific
-	repoID := RepositoryID{result}
-	if valid, err := validation.IsValid(repoID); !valid {
-		return RepositoryID{}, err
-	}
-
-	return repoID, nil
-}
-
-func (id RepositoryID) Validate() []string {
-	result := id.ActorID.Validate()
-	result = append(result, validation.ValidateNotEmpty(id.Source, "source")...)
-	result = append(result, validation.ValidateOneOf(id.Source, []any{"forgejo", "gitea"}, "Source")...)
-	switch id.Source {
-	case "forgejo", "gitea":
-		if strings.ToLower(id.Path) != "api/v1/activitypub/repository-id" && strings.ToLower(id.Path) != "api/activitypub/repository-id" {
-			result = append(result, fmt.Sprintf("path: %q has to be a repo specific api path", id.Path))
-		}
-	}
-	return result
-}
-
-func containsEmptyString(ar []string) bool {
-	for _, elem := range ar {
-		if elem == "" {
-			return true
-		}
-	}
-	return false
-}
-
-func removeEmptyStrings(ls []string) []string {
-	var rs []string
-	for _, str := range ls {
-		if str != "" {
-			rs = append(rs, str)
-		}
-	}
-	return rs
-}
-
-// ----------------------------- newActorID --------------------------------------------
-
 func newActorID(uri string) (ActorID, error) {
 	validatedURI, err := url.ParseRequestURI(uri)
 	if err != nil {
@@ -212,28 +106,21 @@ func newActorID(uri string) (ActorID, error) {
 	return result, nil
 }
 
-// ----------------------------- ForgePerson -------------------------------------
+func containsEmptyString(ar []string) bool {
-
+	for _, elem := range ar {
-// ForgePerson activity data type
+		if elem == "" {
-// swagger:model
+			return true
-type ForgePerson struct {
+		}
-	// swagger:ignore
+	}
-	ap.Actor
+	return false
 }
 
-func (s ForgePerson) MarshalJSON() ([]byte, error) {
+func removeEmptyStrings(ls []string) []string {
-	return s.Actor.MarshalJSON()
+	var rs []string
-}
+	for _, str := range ls {
-
+		if str != "" {
-func (s *ForgePerson) UnmarshalJSON(data []byte) error {
+			rs = append(rs, str)
-	return s.Actor.UnmarshalJSON(data)
+		}
-}
+	}
-
+	return rs
-func (s ForgePerson) Validate() []string {
-	var result []string
-	result = append(result, validation.ValidateNotEmpty(string(s.Type), "Type")...)
-	result = append(result, validation.ValidateOneOf(string(s.Type), []any{string(ap.PersonType)}, "Type")...)
-	result = append(result, validation.ValidateNotEmpty(s.PreferredUsername.String(), "PreferredUsername")...)
-
-	return result
 }

modules/forgefed/actor_person.go

@@ -0,0 +1,122 @@
+// Copyright 2023, 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"fmt"
+	"strings"
+
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+)
+
+// ----------------------------- PersonID --------------------------------------------
+type PersonID struct {
+	ActorID
+}
+
+const (
+	personIDapiPathV1       = "api/v1/activitypub/user-id"
+	personIDapiPathV1Latest = "api/activitypub/user-id"
+)
+
+// Factory function for PersonID. Created struct is asserted to be valid
+func NewPersonID(uri, source string) (PersonID, error) {
+	result, err := newActorID(uri)
+	if err != nil {
+		return PersonID{}, err
+	}
+	result.Source = source
+
+	// validate Person specific path
+	personID := PersonID{result}
+	if valid, err := validation.IsValid(personID); !valid {
+		return PersonID{}, err
+	}
+
+	return personID, nil
+}
+
+func NewPersonIDFromModel(host, schema string, port uint16, softwareName, id string) (PersonID, error) {
+	result := PersonID{}
+	result.ID = id
+	result.Source = softwareName
+	result.Host = host
+	result.HostSchema = schema
+	result.HostPort = port
+	result.IsPortSupplemented = false
+
+	if softwareName == "forgejo" {
+		result.Path = personIDapiPathV1
+	}
+	result.UnvalidatedInput = result.AsURI()
+
+	// validate Person specific path
+	if valid, err := validation.IsValid(result); !valid {
+		return PersonID{}, err
+	}
+
+	return result, nil
+}
+
+func (id PersonID) AsWebfinger() string {
+	result := fmt.Sprintf("@%s@%s", strings.ToLower(id.ID), strings.ToLower(id.Host))
+	return result
+}
+
+func (id PersonID) AsLoginName() string {
+	result := fmt.Sprintf("%s%s", strings.ToLower(id.ID), id.HostSuffix())
+	return result
+}
+
+func (id PersonID) HostSuffix() string {
+	var result string
+	if !id.IsPortSupplemented {
+		result = fmt.Sprintf("-%s-%d", strings.ToLower(id.Host), id.HostPort)
+	} else {
+		result = fmt.Sprintf("-%s", strings.ToLower(id.Host))
+	}
+	return result
+}
+
+func (id PersonID) Validate() []string {
+	result := id.ActorID.Validate()
+	result = append(result, validation.ValidateNotEmpty(id.Source, "source")...)
+	result = append(result, validation.ValidateOneOf(id.Source, []any{"forgejo", "gitea", "mastodon", "gotosocial"}, "Source")...)
+	if id.Source == "forgejo" {
+		result = append(result, validation.ValidateNotEmpty(id.Path, "path")...)
+		if strings.ToLower(id.Path) != personIDapiPathV1 && strings.ToLower(id.Path) != personIDapiPathV1Latest {
+			result = append(result, fmt.Sprintf("path: %q has to be a person specific api path", id.Path))
+		}
+	}
+
+	return result
+}
+
+// ----------------------------- ForgePerson -------------------------------------
+
+// ForgePerson activity data type
+// swagger:model
+type ForgePerson struct {
+	// swagger:ignore
+	ap.Actor
+}
+
+func (s ForgePerson) MarshalJSON() ([]byte, error) {
+	return s.Actor.MarshalJSON()
+}
+
+func (s *ForgePerson) UnmarshalJSON(data []byte) error {
+	return s.Actor.UnmarshalJSON(data)
+}
+
+func (s ForgePerson) Validate() []string {
+	var result []string
+	result = append(result, validation.ValidateNotEmpty(string(s.Type), "Type")...)
+	result = append(result, validation.ValidateOneOf(string(s.Type), []any{string(ap.PersonType)}, "Type")...)
+	result = append(result, validation.ValidateNotEmpty(s.PreferredUsername.String(), "PreferredUsername")...)
+
+	return result
+}

modules/forgefed/actor_person_test.go

@@ -0,0 +1,268 @@
+// Copyright 2023, 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewPersonIdFromModel(t *testing.T) {
+	expected := PersonID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "https"
+	expected.Path = "api/v1/activitypub/user-id"
+	expected.Host = "an.other.host"
+	expected.HostPort = 443
+	expected.IsPortSupplemented = false
+	expected.UnvalidatedInput = "https://an.other.host:443/api/v1/activitypub/user-id/1"
+
+	sut, _ := NewPersonIDFromModel("an.other.host", "https", 443, "forgejo", "1")
+	assert.Equal(t, expected, sut)
+}
+
+func TestNewPersonId(t *testing.T) {
+	var sut, expected PersonID
+	var err error
+
+	expected = PersonID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "https"
+	expected.Path = "api/v1/activitypub/user-id"
+	expected.Host = "an.other.host"
+	expected.HostPort = 443
+	expected.IsPortSupplemented = true
+	expected.UnvalidatedInput = "https://an.other.host/api/v1/activitypub/user-id/1"
+
+	sut, err = NewPersonID("https://an.other.host/api/v1/activitypub/user-id/1", "forgejo")
+	require.NoError(t, err)
+	assert.Equal(t, expected, sut)
+
+	expected = PersonID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "https"
+	expected.Path = "api/v1/activitypub/user-id"
+	expected.Host = "an.other.host"
+	expected.HostPort = 443
+	expected.IsPortSupplemented = false
+	expected.UnvalidatedInput = "https://an.other.host:443/api/v1/activitypub/user-id/1"
+
+	sut, _ = NewPersonID("https://an.other.host:443/api/v1/activitypub/user-id/1", "forgejo")
+	assert.Equal(t, expected, sut)
+
+	expected = PersonID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "http"
+	expected.Path = "api/v1/activitypub/user-id"
+	expected.Host = "an.other.host"
+	expected.HostPort = 80
+	expected.IsPortSupplemented = false
+	expected.UnvalidatedInput = "http://an.other.host:80/api/v1/activitypub/user-id/1"
+
+	sut, _ = NewPersonID("http://an.other.host:80/api/v1/activitypub/user-id/1", "forgejo")
+	assert.Equal(t, expected, sut)
+
+	expected = PersonID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "https"
+	expected.Path = "api/v1/activitypub/user-id"
+	expected.Host = "an.other.host"
+	expected.HostPort = 443
+	expected.IsPortSupplemented = false
+	expected.UnvalidatedInput = "https://an.other.host:443/api/v1/activitypub/user-id/1"
+
+	sut, _ = NewPersonID("HTTPS://an.other.host:443/api/v1/activitypub/user-id/1", "forgejo")
+	assert.Equal(t, expected, sut)
+
+	expected = PersonID{}
+	expected.ID = "@me"
+	expected.Source = "gotosocial"
+	expected.HostSchema = "https"
+	expected.Path = ""
+	expected.Host = "an.other.host"
+	expected.HostPort = 443
+	expected.IsPortSupplemented = true
+	expected.UnvalidatedInput = "https://an.other.host/@me"
+
+	sut, err = NewPersonID("https://an.other.host/@me", "gotosocial")
+	require.NoError(t, err)
+	assert.Equal(t, expected, sut)
+}
+
+func TestPersonIdValidation(t *testing.T) {
+	sut := PersonID{}
+	sut.ID = "1"
+	sut.Source = "forgejo"
+	sut.HostSchema = "https"
+	sut.Path = ""
+	sut.Host = "an.other.host"
+	sut.HostPort = 443
+	sut.IsPortSupplemented = true
+	sut.UnvalidatedInput = "https://an.other.host/1"
+
+	result, err := validation.IsValid(sut)
+	assert.False(t, result)
+	require.EqualError(t, err, "Validation Error: forgefed.PersonID: path should not be empty\npath: \"\" has to be a person specific api path")
+
+	sut = PersonID{}
+	sut.ID = "1"
+	sut.Source = "mastodon"
+	sut.HostSchema = "https"
+	sut.Path = ""
+	sut.Host = "an.other.host"
+	sut.HostPort = 443
+	sut.IsPortSupplemented = true
+	sut.UnvalidatedInput = "https://an.other.host/1"
+
+	result, err = validation.IsValid(sut)
+	assert.True(t, result)
+	require.NoError(t, err)
+
+	sut = PersonID{}
+	sut.ID = "1"
+	sut.Source = "forgejo"
+	sut.HostSchema = "https"
+	sut.Path = "path"
+	sut.Host = "an.other.host"
+	sut.HostPort = 443
+	sut.IsPortSupplemented = true
+	sut.UnvalidatedInput = "https://an.other.host/path/1"
+
+	result, err = validation.IsValid(sut)
+	assert.False(t, result)
+	require.EqualError(t, err, "Validation Error: forgefed.PersonID: path: \"path\" has to be a person specific api path")
+
+	sut = PersonID{}
+	sut.ID = "1"
+	sut.Source = "forgejox"
+	sut.HostSchema = "https"
+	sut.Path = "api/v1/activitypub/user-id"
+	sut.Host = "an.other.host"
+	sut.HostPort = 443
+	sut.IsPortSupplemented = true
+	sut.UnvalidatedInput = "https://an.other.host/api/v1/activitypub/user-id/1"
+
+	result, err = validation.IsValid(sut)
+	assert.False(t, result)
+	require.EqualError(t, err, "Validation Error: forgefed.PersonID: Field Source contains the value forgejox, which is not in allowed subset [forgejo gitea mastodon gotosocial]")
+}
+
+func TestWebfingerId(t *testing.T) {
+	sut, _ := NewPersonID("https://codeberg.org/api/v1/activitypub/user-id/12345", "forgejo")
+	assert.Equal(t, "@12345@codeberg.org", sut.AsWebfinger())
+}
+
+func TestShouldThrowErrorOnInvalidInput(t *testing.T) {
+	var err any
+	_, err = NewPersonID("", "forgejo")
+	if err == nil {
+		t.Errorf("empty input should be invalid.")
+	}
+	_, err = NewPersonID("http://localhost:3000/api/v1/something", "forgejo")
+	if err == nil {
+		t.Errorf("localhost uris are not external")
+	}
+	_, err = NewPersonID("./api/v1/something", "forgejo")
+	if err == nil {
+		t.Errorf("relative uris are not allowed")
+	}
+	_, err = NewPersonID("http://1.2.3.4/api/v1/something", "forgejo")
+	if err == nil {
+		t.Errorf("uri may not be ip-4 based")
+	}
+	_, err = NewPersonID("http:///[fe80::1ff:fe23:4567:890a%25eth0]/api/v1/something", "forgejo")
+	if err == nil {
+		t.Errorf("uri may not be ip-6 based")
+	}
+	_, err = NewPersonID("https://codeberg.org/api/v1/activitypub/../activitypub/user-id/12345", "forgejo")
+	if err == nil {
+		t.Errorf("uri may not contain relative path elements")
+	}
+	_, err = NewPersonID("https://myuser@an.other.host/api/v1/activitypub/user-id/1", "forgejo")
+	if err == nil {
+		t.Errorf("uri may not contain unparsed elements")
+	}
+	_, err = NewPersonID("https://an.other.host/api/v1/activitypub/user-id/1", "forgejo")
+	if err != nil {
+		t.Errorf("this uri should be valid but was: %v", err)
+	}
+}
+
+func Test_PersonMarshalJSON(t *testing.T) {
+	sut := ForgePerson{}
+	sut.Type = "Person"
+	sut.PreferredUsername = ap.NaturalLanguageValuesNew()
+	sut.PreferredUsername.Set("en", ap.Content("MaxMuster"))
+	result, _ := sut.MarshalJSON()
+	assert.JSONEq(t, `{"type":"Person","preferredUsername":"MaxMuster"}`, string(result), "Expected string is not equal")
+}
+
+func Test_PersonUnmarshalJSON(t *testing.T) {
+	expected := &ForgePerson{
+		Actor: ap.Actor{
+			Type: "Person",
+			PreferredUsername: ap.NaturalLanguageValues{
+				ap.LangRefValue{Ref: "en", Value: []byte("MaxMuster")},
+			},
+		},
+	}
+	sut := new(ForgePerson)
+	err := sut.UnmarshalJSON([]byte(`{"type":"Person","preferredUsername":"MaxMuster"}`))
+	if err != nil {
+		t.Errorf("UnmarshalJSON() unexpected error: %v", err)
+	}
+	x, _ := expected.MarshalJSON()
+	y, _ := sut.MarshalJSON()
+	if !reflect.DeepEqual(x, y) {
+		t.Errorf("UnmarshalJSON() expected: %q got: %q", x, y)
+	}
+
+	expectedStr := strings.ReplaceAll(strings.ReplaceAll(`{
+		"id":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10",
+		"type":"Person",
+		"icon":{"type":"Image","mediaType":"image/png","url":"https://federated-repo.prod.meissa.de/avatar/fa7f9c4af2a64f41b1bef292bf872614"},
+		"url":"https://federated-repo.prod.meissa.de/stargoose9",
+		"inbox":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10/inbox",
+		"outbox":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10/outbox",
+		"preferredUsername":"stargoose9",
+		"publicKey":{"id":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10#main-key",
+			"owner":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10",
+			"publicKeyPem":"-----BEGIN PUBLIC KEY-----\nMIIBoj...XAgMBAAE=\n-----END PUBLIC KEY-----\n"}}`,
+		"\n", ""),
+		"\t", "")
+	err = sut.UnmarshalJSON([]byte(expectedStr))
+	if err != nil {
+		t.Errorf("UnmarshalJSON() unexpected error: %v", err)
+	}
+	result, _ := sut.MarshalJSON()
+	assert.JSONEq(t, expectedStr, string(result), "Expected string is not equal")
+}
+
+func TestForgePersonValidation(t *testing.T) {
+	sut := new(ForgePerson)
+	sut.UnmarshalJSON([]byte(`{"type":"Person","preferredUsername":"MaxMuster"}`))
+	if res, _ := validation.IsValid(sut); !res {
+		t.Errorf("sut expected to be valid: %v\n", sut.Validate())
+	}
+}
+
+func TestAsloginName(t *testing.T) {
+	sut, _ := NewPersonID("https://codeberg.org/api/v1/activitypub/user-id/12345", "forgejo")
+	assert.Equal(t, "12345-codeberg.org", sut.AsLoginName())
+
+	sut, _ = NewPersonID("https://codeberg.org:443/api/v1/activitypub/user-id/12345", "forgejo")
+	assert.Equal(t, "12345-codeberg.org-443", sut.AsLoginName())
+}

modules/forgefed/actor_repository.go

@@ -0,0 +1,52 @@
+// Copyright 2023, 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"fmt"
+	"strings"
+
+	"forgejo.org/modules/validation"
+)
+
+// ----------------------------- RepositoryID --------------------------------------------
+
+type RepositoryID struct {
+	ActorID
+}
+
+const (
+	repositoryIDapiPathV1       = "api/v1/activitypub/repository-id"
+	repositoryIDapiPathV1Latest = "api/activitypub/repository-id"
+)
+
+// Factory function for RepositoryID. Created struct is asserted to be valid.
+func NewRepositoryID(uri, source string) (RepositoryID, error) {
+	result, err := newActorID(uri)
+	if err != nil {
+		return RepositoryID{}, err
+	}
+	result.Source = source
+
+	// validate Person specific
+	repoID := RepositoryID{result}
+	if valid, err := validation.IsValid(repoID); !valid {
+		return RepositoryID{}, err
+	}
+
+	return repoID, nil
+}
+
+func (id RepositoryID) Validate() []string {
+	result := id.ActorID.Validate()
+	result = append(result, validation.ValidateNotEmpty(id.Source, "source")...)
+	result = append(result, validation.ValidateOneOf(id.Source, []any{"forgejo", "gitea"}, "Source")...)
+	if id.Source == "forgejo" {
+		result = append(result, validation.ValidateNotEmpty(id.Path, "path")...)
+		if strings.ToLower(id.Path) != repositoryIDapiPathV1 && strings.ToLower(id.Path) != repositoryIDapiPathV1Latest {
+			result = append(result, fmt.Sprintf("path: %q has to be a repo specific api path", id.Path))
+		}
+	}
+	return result
+}

modules/forgefed/actor_repository_test.go

@@ -0,0 +1,45 @@
+// Copyright 2023, 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"testing"
+
+	"forgejo.org/modules/setting"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewRepositoryId(t *testing.T) {
+	var sut, expected RepositoryID
+	var err error
+	setting.AppURL = "http://localhost:3000/"
+
+	expected = RepositoryID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "http"
+	expected.Path = ""
+	expected.Host = "localhost"
+	expected.HostPort = 3000
+	expected.IsPortSupplemented = false
+	expected.UnvalidatedInput = "http://localhost:3000/1"
+
+	_, err = NewRepositoryID("https://an.other.host/api/v1/activitypub/user-id/1", "forgejo")
+	require.EqualError(t, err, "Validation Error: forgefed.RepositoryID: path: \"api/v1/activitypub/user-id\" has to be a repo specific api path")
+
+	expected = RepositoryID{}
+	expected.ID = "1"
+	expected.Source = "forgejo"
+	expected.HostSchema = "http"
+	expected.Path = "api/activitypub/repository-id"
+	expected.Host = "localhost"
+	expected.HostPort = 3000
+	expected.IsPortSupplemented = false
+	expected.UnvalidatedInput = "http://localhost:3000/api/activitypub/repository-id/1"
+	sut, err = NewRepositoryID("http://localhost:3000/api/activitypub/repository-id/1", "forgejo")
+	require.NoError(t, err)
+	assert.Equal(t, expected, sut)
+}

modules/forgefed/actor_test.go

@@ -4,258 +4,71 @@
 package forgefed
 
 import (
-	"reflect"
-	"strings"
 	"testing"
 
-	"forgejo.org/modules/setting"
+	"github.com/stretchr/testify/assert"
-	"forgejo.org/modules/validation"
+	"github.com/stretchr/testify/require"
-
-	ap "github.com/go-ap/activitypub"
 )
 
-func TestNewPersonId(t *testing.T) {
+func TestActorNew(t *testing.T) {
-	expected := PersonID{}
+	sut, err := NewActorID("https://an.other.forgejo.host/api/v1/activitypub/user-id/5")
-	expected.ID = "1"
+	require.NoError(t, err)
-	expected.Source = "forgejo"
+	assert.Equal(t, ActorID{
-	expected.HostSchema = "https"
+		ID:                 "5",
-	expected.Path = "api/v1/activitypub/user-id"
+		HostSchema:         "https",
-	expected.Host = "an.other.host"
+		Path:               "api/v1/activitypub/user-id",
-	expected.HostPort = 443
+		Host:               "an.other.forgejo.host",
-	expected.IsPortSupplemented = true
+		HostPort:           443,
-	expected.UnvalidatedInput = "https://an.other.host/api/v1/activitypub/user-id/1"
+		UnvalidatedInput:   "https://an.other.forgejo.host/api/v1/activitypub/user-id/5",
+		IsPortSupplemented: true,
+	}, sut)
 
-	sut, _ := NewPersonID("https://an.other.host/api/v1/activitypub/user-id/1", "forgejo")
+	sut, err = NewActorID("https://an.other.forgejo.host/api/v1/activitypub/actor")
-	if sut != expected {
+	require.NoError(t, err)
-		t.Errorf("expected: %v\n but was: %v\n", expected, sut)
+	assert.Equal(t, ActorID{
-	}
+		ID:                 "actor",
+		HostSchema:         "https",
+		Path:               "api/v1/activitypub",
+		Host:               "an.other.forgejo.host",
+		HostPort:           443,
+		UnvalidatedInput:   "https://an.other.forgejo.host/api/v1/activitypub/actor",
+		IsPortSupplemented: true,
+	}, sut)
 
-	expected = PersonID{}
+	sut, err = NewActorID("https://an.other.gts.host/users/me")
-	expected.ID = "1"
+	require.NoError(t, err)
-	expected.Source = "forgejo"
+	assert.Equal(t, ActorID{
-	expected.HostSchema = "https"
+		ID:                 "me",
-	expected.Path = "api/v1/activitypub/user-id"
+		HostSchema:         "https",
-	expected.Host = "an.other.host"
+		Path:               "users",
-	expected.HostPort = 443
+		Host:               "an.other.gts.host",
-	expected.IsPortSupplemented = false
+		HostPort:           443,
-	expected.UnvalidatedInput = "https://an.other.host:443/api/v1/activitypub/user-id/1"
+		UnvalidatedInput:   "https://an.other.gts.host/users/me",
-
+		IsPortSupplemented: true,
-	sut, _ = NewPersonID("https://an.other.host:443/api/v1/activitypub/user-id/1", "forgejo")
+	}, sut)
-	if sut != expected {
-		t.Errorf("expected: %v\n but was: %v\n", expected, sut)
-	}
-
-	expected = PersonID{}
-	expected.ID = "1"
-	expected.Source = "forgejo"
-	expected.HostSchema = "http"
-	expected.Path = "api/v1/activitypub/user-id"
-	expected.Host = "an.other.host"
-	expected.HostPort = 80
-	expected.IsPortSupplemented = false
-	expected.UnvalidatedInput = "http://an.other.host:80/api/v1/activitypub/user-id/1"
-
-	sut, _ = NewPersonID("http://an.other.host:80/api/v1/activitypub/user-id/1", "forgejo")
-	if sut != expected {
-		t.Errorf("expected: %v\n but was: %v\n", expected, sut)
-	}
-
-	expected = PersonID{}
-	expected.ID = "1"
-	expected.Source = "forgejo"
-	expected.HostSchema = "https"
-	expected.Path = "api/v1/activitypub/user-id"
-	expected.Host = "an.other.host"
-	expected.HostPort = 443
-	expected.IsPortSupplemented = false
-	expected.UnvalidatedInput = "https://an.other.host:443/api/v1/activitypub/user-id/1"
-
-	sut, _ = NewPersonID("HTTPS://an.other.host:443/api/v1/activitypub/user-id/1", "forgejo")
-	if sut != expected {
-		t.Errorf("expected: %v\n but was: %v\n", expected, sut)
-	}
-}
-
-func TestNewRepositoryId(t *testing.T) {
-	setting.AppURL = "http://localhost:3000/"
-	expected := RepositoryID{}
-	expected.ID = "1"
-	expected.Source = "forgejo"
-	expected.HostSchema = "http"
-	expected.Path = "api/activitypub/repository-id"
-	expected.Host = "localhost"
-	expected.HostPort = 3000
-	expected.IsPortSupplemented = false
-	expected.UnvalidatedInput = "http://localhost:3000/api/activitypub/repository-id/1"
-	sut, _ := NewRepositoryID("http://localhost:3000/api/activitypub/repository-id/1", "forgejo")
-	if sut != expected {
-		t.Errorf("expected: %v\n but was: %v\n", expected, sut)
-	}
 }
 
 func TestActorIdValidation(t *testing.T) {
 	sut := ActorID{}
-	sut.Source = "forgejo"
 	sut.HostSchema = "https"
 	sut.Path = "api/v1/activitypub/user-id"
 	sut.Host = "an.other.host"
 	sut.HostPort = 443
 	sut.IsPortSupplemented = true
 	sut.UnvalidatedInput = "https://an.other.host/api/v1/activitypub/user-id/"
-	if sut.Validate()[0] != "userId should not be empty" {
+	result := sut.Validate()
-		t.Errorf("validation error expected but was: %v\n", sut.Validate())
+	assert.Len(t, result, 1)
-	}
+	assert.Equal(t, "ID should not be empty", result[0])
 
 	sut = ActorID{}
 	sut.ID = "1"
-	sut.Source = "forgejo"
 	sut.HostSchema = "https"
 	sut.Path = "api/v1/activitypub/user-id"
 	sut.Host = "an.other.host"
 	sut.HostPort = 443
 	sut.IsPortSupplemented = true
 	sut.UnvalidatedInput = "https://an.other.host/api/v1/activitypub/user-id/1?illegal=action"
-	if sut.Validate()[0] != "not all input was parsed, \nUnvalidated Input:\"https://an.other.host/api/v1/activitypub/user-id/1?illegal=action\" \nParsed URI: \"https://an.other.host/api/v1/activitypub/user-id/1\"" {
+	result = sut.Validate()
-		t.Errorf("validation error expected but was: %v\n", sut.Validate()[0])
+	assert.Len(t, result, 1)
-	}
+	assert.Equal(t, "not all input was parsed, \nUnvalidated Input:\"https://an.other.host/api/v1/activitypub/user-id/1?illegal=action\" \nParsed URI: \"https://an.other.host/api/v1/activitypub/user-id/1\"", result[0])
-}
-
-func TestPersonIdValidation(t *testing.T) {
-	sut := PersonID{}
-	sut.ID = "1"
-	sut.Source = "forgejo"
-	sut.HostSchema = "https"
-	sut.Path = "path"
-	sut.Host = "an.other.host"
-	sut.HostPort = 443
-	sut.IsPortSupplemented = true
-	sut.UnvalidatedInput = "https://an.other.host/path/1"
-
-	_, err := validation.IsValid(sut)
-	if validation.IsErrNotValid(err) && strings.Contains(err.Error(), "path: \"path\" has to be a person specific api path\n") {
-		t.Errorf("validation error expected but was: %v\n", err)
-	}
-
-	sut = PersonID{}
-	sut.ID = "1"
-	sut.Source = "forgejox"
-	sut.HostSchema = "https"
-	sut.Path = "api/v1/activitypub/user-id"
-	sut.Host = "an.other.host"
-	sut.HostPort = 443
-	sut.IsPortSupplemented = true
-	sut.UnvalidatedInput = "https://an.other.host/api/v1/activitypub/user-id/1"
-	if sut.Validate()[0] != "Field Source contains the value forgejox, which is not in allowed subset [forgejo gitea]" {
-		t.Errorf("validation error expected but was: %v\n", sut.Validate()[0])
-	}
-}
-
-func TestWebfingerId(t *testing.T) {
-	sut, _ := NewPersonID("https://codeberg.org/api/v1/activitypub/user-id/12345", "forgejo")
-	if sut.AsWebfinger() != "@12345@codeberg.org" {
-		t.Errorf("wrong webfinger: %v", sut.AsWebfinger())
-	}
-
-	sut, _ = NewPersonID("https://Codeberg.org/api/v1/activitypub/user-id/12345", "forgejo")
-	if sut.AsWebfinger() != "@12345@codeberg.org" {
-		t.Errorf("wrong webfinger: %v", sut.AsWebfinger())
-	}
-}
-
-func TestShouldThrowErrorOnInvalidInput(t *testing.T) {
-	var err any
-	_, err = NewPersonID("", "forgejo")
-	if err == nil {
-		t.Error("empty input should be invalid.")
-	}
-	_, err = NewPersonID("http://localhost:3000/api/v1/something", "forgejo")
-	if err == nil {
-		t.Error("localhost uris are not external")
-	}
-	_, err = NewPersonID("./api/v1/something", "forgejo")
-	if err == nil {
-		t.Error("relative uris are not allowed")
-	}
-	_, err = NewPersonID("http://1.2.3.4/api/v1/something", "forgejo")
-	if err == nil {
-		t.Error("uri may not be ip-4 based")
-	}
-	_, err = NewPersonID("http:///[fe80::1ff:fe23:4567:890a%25eth0]/api/v1/something", "forgejo")
-	if err == nil {
-		t.Error("uri may not be ip-6 based")
-	}
-	_, err = NewPersonID("https://codeberg.org/api/v1/activitypub/../activitypub/user-id/12345", "forgejo")
-	if err == nil {
-		t.Error("uri may not contain relative path elements")
-	}
-	_, err = NewPersonID("https://myuser@an.other.host/api/v1/activitypub/user-id/1", "forgejo")
-	if err == nil {
-		t.Error("uri may not contain unparsed elements")
-	}
-	_, err = NewPersonID("https://an.other.host/api/v1/activitypub/user-id/1", "forgejo")
-	if err != nil {
-		t.Errorf("this uri should be valid but was: %v", err)
-	}
-}
-
-func Test_PersonMarshalJSON(t *testing.T) {
-	sut := ForgePerson{}
-	sut.Type = "Person"
-	sut.PreferredUsername = ap.NaturalLanguageValuesNew()
-	sut.PreferredUsername.Set("en", ap.Content("MaxMuster"))
-	result, _ := sut.MarshalJSON()
-	if string(result) != "{\"type\":\"Person\",\"preferredUsername\":\"MaxMuster\"}" {
-		t.Errorf("MarshalJSON() was = %q", result)
-	}
-}
-
-func Test_PersonUnmarshalJSON(t *testing.T) {
-	expected := &ForgePerson{
-		Actor: ap.Actor{
-			Type: "Person",
-			PreferredUsername: ap.NaturalLanguageValues{
-				ap.LangRefValue{Ref: "en", Value: []byte("MaxMuster")},
-			},
-		},
-	}
-	sut := new(ForgePerson)
-	err := sut.UnmarshalJSON([]byte(`{"type":"Person","preferredUsername":"MaxMuster"}`))
-	if err != nil {
-		t.Errorf("UnmarshalJSON() unexpected error: %v", err)
-	}
-	x, _ := expected.MarshalJSON()
-	y, _ := sut.MarshalJSON()
-	if !reflect.DeepEqual(x, y) {
-		t.Errorf("UnmarshalJSON() expected: %q got: %q", x, y)
-	}
-
-	expectedStr := strings.ReplaceAll(strings.ReplaceAll(`{
-		"id":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10",
-		"type":"Person",
-		"icon":{"type":"Image","mediaType":"image/png","url":"https://federated-repo.prod.meissa.de/avatar/fa7f9c4af2a64f41b1bef292bf872614"},
-		"url":"https://federated-repo.prod.meissa.de/stargoose9",
-		"inbox":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10/inbox",
-		"outbox":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10/outbox",
-		"preferredUsername":"stargoose9",
-		"publicKey":{"id":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10#main-key",
-			"owner":"https://federated-repo.prod.meissa.de/api/v1/activitypub/user-id/10",
-			"publicKeyPem":"-----BEGIN PUBLIC KEY-----\nMIIBoj...XAgMBAAE=\n-----END PUBLIC KEY-----\n"}}`,
-		"\n", ""),
-		"\t", "")
-	err = sut.UnmarshalJSON([]byte(expectedStr))
-	if err != nil {
-		t.Errorf("UnmarshalJSON() unexpected error: %v", err)
-	}
-	result, _ := sut.MarshalJSON()
-	if expectedStr != string(result) {
-		t.Errorf("UnmarshalJSON() expected: %q got: %q", expectedStr, result)
-	}
-}
-
-func TestForgePersonValidation(t *testing.T) {
-	sut := new(ForgePerson)
-	sut.UnmarshalJSON([]byte(`{"type":"Person","preferredUsername":"MaxMuster"}`))
-	if res, _ := validation.IsValid(sut); !res {
-		t.Errorf("sut expected to be valid: %v\n", sut.Validate())
-	}
 }

modules/forgefed/forgefed.go

@@ -1,4 +1,4 @@
-// Copyright 2023 The Forgejo Authors. All rights reserved.
+// Copyright 2023, 2025 The Forgejo Authors. All rights reserved.
 // SPDX-License-Identifier: MIT
 
 package forgefed

modules/forgefed/object_user_activity_note.go

@@ -0,0 +1,68 @@
+// Copyright 2024, 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"time"
+
+	user_model "forgejo.org/models/user"
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+)
+
+// ForgeFollow activity data type
+// swagger:model
+type ForgeUserActivityNote struct {
+	// swagger.ignore
+	ap.Object
+}
+
+func NewForgeUserActivityNoteFromAp(item ap.Item) (ForgeUserActivityNote, error) {
+	result := ForgeUserActivityNote{}
+	object := item.(*ap.Object)
+	result.Object = *object
+	if valid, err := validation.IsValid(result); !valid {
+		return ForgeUserActivityNote{}, err
+	}
+	return result, nil
+}
+
+// TODO: Unused - might be removed
+func newNote(doer *user_model.User, content, id string, published time.Time) (ForgeUserActivityNote, error) {
+	note := ForgeUserActivityNote{}
+	note.Type = ap.NoteType
+	note.AttributedTo = ap.IRI(doer.APActorID())
+	note.Content = ap.NaturalLanguageValues{
+		{
+			Ref:   ap.NilLangRef,
+			Value: ap.Content(content),
+		},
+	}
+	note.ID = ap.IRI(id)
+	note.Published = published
+	note.URL = ap.IRI(id)
+	note.To = ap.ItemCollection{
+		ap.IRI("https://www.w3.org/ns/activitystreams#Public"),
+	}
+	note.CC = ap.ItemCollection{
+		ap.IRI(doer.APActorID() + "/followers"),
+	}
+
+	if valid, err := validation.IsValid(note); !valid {
+		return ForgeUserActivityNote{}, err
+	}
+
+	return note, nil
+}
+
+func (note ForgeUserActivityNote) Validate() []string {
+	var result []string
+	result = append(result, validation.ValidateNotEmpty(string(note.Type), "type")...)
+	result = append(result, validation.ValidateOneOf(string(note.Type), []any{"Note"}, "type")...)
+	result = append(result, validation.ValidateNotEmpty(note.Content.String(), "content")...)
+	result = append(result, validation.ValidateIDExists(note.URL, "url")...)
+
+	return result
+}

modules/forgefed/object_user_activity_note_test.go

@@ -0,0 +1,28 @@
+// Copyright 2025 The Forgejo Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package forgefed
+
+import (
+	"testing"
+
+	"forgejo.org/modules/validation"
+
+	ap "github.com/go-ap/activitypub"
+)
+
+func Test_UserActivityNoteValidation(t *testing.T) {
+	sut := ForgeUserActivityNote{}
+	sut.Type = "Note"
+	sut.Content = ap.NaturalLanguageValues{
+		{
+			Ref:   ap.NilLangRef,
+			Value: ap.Content("Any Content!"),
+		},
+	}
+	sut.URL = ap.IRI("example.org/user-id/57")
+
+	if res, _ := validation.IsValid(sut); !res {
+		t.Errorf("sut expected to be valid: %v\n", sut.Validate())
+	}
+}