feat(api): ✨ username availability

app/commands/check_username_availability.go

@@ -0,0 +1,14 @@
+package commands
+
+import . "github.com/reiver/greatape/components/contracts"
+
+func CheckUsernameAvailability(x IDispatcher, username string) (ICheckUsernameAvailabilityResult, error) {
+	isAvailable := true
+	if x.IdentityExistsWhich(func(identity IIdentity) bool {
+		return identity.Username() == username
+	}) {
+		isAvailable = false
+	}
+
+	return x.NewCheckUsernameAvailabilityResult(isAvailable), nil
+}

components/api/api_test.go

@@ -45,6 +45,18 @@ func TestEchoApi(test *testing.T) {
 	}
 }
 
+func TestCheckUsernameAvailabilityApi(test *testing.T) {
+	input := &CheckUsernameAvailabilityRequest{
+		Username: "username",
+	}
+
+	if output, err := api.CheckUsernameAvailability(input); err != nil {
+		test.Fatal(err)
+	} else if output == nil {
+		test.Fail()
+	}
+}
+
 func TestSignupApi(test *testing.T) {
 	input := &SignupRequest{
 		Username: "username",

components/api/handlers/check_username_availability_handler.go

@@ -0,0 +1,45 @@
+package handlers
+
+import (
+	"net/http"
+
+	. "github.com/reiver/greatape/components/api/protobuf"
+	. "github.com/reiver/greatape/components/contracts"
+	. "github.com/xeronith/diamante/contracts/network/http"
+	pipeline "github.com/xeronith/diamante/network/http"
+)
+
+type checkUsernameAvailabilityHandler struct {
+}
+
+func CheckUsernameAvailabilityHandler() IHttpHandler {
+	return &checkUsernameAvailabilityHandler{}
+}
+
+func (handler *checkUsernameAvailabilityHandler) Method() string {
+	return http.MethodPost
+}
+
+func (handler *checkUsernameAvailabilityHandler) Path() string {
+	return "/api/v1/check-username"
+}
+
+func (handler *checkUsernameAvailabilityHandler) HandlerFunc() HttpHandlerFunc {
+	return func(x IServerDispatcher) error {
+		request := &CheckUsernameAvailabilityRequest{}
+		result := &CheckUsernameAvailabilityResult{}
+
+		onRequestUnmarshalled := func(request *CheckUsernameAvailabilityRequest) {
+		}
+
+		return pipeline.Handle(x,
+			"check_username_availability",
+			CHECK_USERNAME_AVAILABILITY_REQUEST,
+			CHECK_USERNAME_AVAILABILITY_RESULT,
+			request, result,
+			onRequestUnmarshalled,
+			nil,
+			false,
+		)
+	}
+}

components/api/handlers/factory.go

@@ -6,24 +6,25 @@ type httpHandlerFactory struct{}
 
 func (factory *httpHandlerFactory) Handlers() []IHttpHandler {
 	return []IHttpHandler{
-		EchoHandler(),                 // │ P . /api/v1/echo
+		EchoHandler(),                      // │ P . /api/v1/echo
-		SignupHandler(),               // │ P . /api/v1/signup
+		CheckUsernameAvailabilityHandler(), // │ P . /api/v1/check-username
-		VerifyHandler(),               // │ P . /api/v1/verify
+		SignupHandler(),                    // │ P . /api/v1/signup
-		LoginHandler(),                // │ P . /api/v1/login
+		VerifyHandler(),                    // │ P . /api/v1/verify
-		GetProfileByUserHandler(),     // │ G . /api/v1/profile
+		LoginHandler(),                     // │ P . /api/v1/login
-		UpdateProfileByUserHandler(),  // │ P . /api/v1/profile
+		GetProfileByUserHandler(),          // │ G . /api/v1/profile
-		LogoutHandler(),               // │ P . /api/v1/logout
+		UpdateProfileByUserHandler(),       // │ P . /api/v1/profile
-		WebfingerHandler(),            // │ G . /.well-known/webfinger
+		LogoutHandler(),                    // │ P . /api/v1/logout
-		GetPackagesHandler(),          // │ G . /.well-known/packages.txt
+		WebfingerHandler(),                 // │ G . /.well-known/webfinger
-		GetActorHandler(),             // │ G . /u/:username
+		GetPackagesHandler(),               // │ G . /.well-known/packages.txt
-		FollowActorHandler(),          // │ G . /u/:username/follow
+		GetActorHandler(),                  // │ G . /u/:username
-		AuthorizeInteractionHandler(), // │ G . /authorize_interaction
+		FollowActorHandler(),               // │ G . /u/:username/follow
-		GetFollowersHandler(),         // │ G . /u/:username/followers
+		AuthorizeInteractionHandler(),      // │ G . /authorize_interaction
-		GetFollowingHandler(),         // │ G . /u/:username/following
+		GetFollowersHandler(),              // │ G . /u/:username/followers
-		PostToOutboxHandler(),         // │ P . /u/:username/outbox
+		GetFollowingHandler(),              // │ G . /u/:username/following
-		GetOutboxHandler(),            // │ G . /u/:username/outbox
+		PostToOutboxHandler(),              // │ P . /u/:username/outbox
-		PostToInboxHandler(),          // │ P . /u/:username/inbox
+		GetOutboxHandler(),                 // │ G . /u/:username/outbox
-		GetInboxHandler(),             // │ G . /u/:username/inbox
+		PostToInboxHandler(),               // │ P . /u/:username/inbox
+		GetInboxHandler(),                  // │ G . /u/:username/inbox
 	}
 }
 

components/api/operations/check_username_availability_operation.go

@@ -0,0 +1,51 @@
+package operations
+
+import (
+	. "github.com/reiver/greatape/components/api/protobuf"
+	. "github.com/reiver/greatape/components/api/services"
+	. "github.com/reiver/greatape/components/contracts"
+	. "github.com/xeronith/diamante/contracts/operation"
+	. "github.com/xeronith/diamante/contracts/service"
+	. "github.com/xeronith/diamante/contracts/system"
+	. "github.com/xeronith/diamante/operation"
+)
+
+type checkUsernameAvailabilityOperation struct {
+	Operation
+
+	run func(IContext, *CheckUsernameAvailabilityRequest) (*CheckUsernameAvailabilityResult, error)
+}
+
+func CheckUsernameAvailabilityOperation() IOperation {
+	return &checkUsernameAvailabilityOperation{
+		run: CheckUsernameAvailabilityService,
+	}
+}
+
+func (operation *checkUsernameAvailabilityOperation) Id() (ID, ID) {
+	return CHECK_USERNAME_AVAILABILITY_REQUEST, CHECK_USERNAME_AVAILABILITY_RESULT
+}
+
+func (operation *checkUsernameAvailabilityOperation) InputContainer() Pointer {
+	return new(CheckUsernameAvailabilityRequest)
+}
+
+func (operation *checkUsernameAvailabilityOperation) OutputContainer() Pointer {
+	return new(CheckUsernameAvailabilityResult)
+}
+
+func (operation *checkUsernameAvailabilityOperation) Execute(context IContext, payload Pointer) (Pointer, error) {
+	return operation.run(context, payload.(*CheckUsernameAvailabilityRequest))
+}
+
+/*
+func (operation *checkUsernameAvailabilityOperation) ExecutionTimeLimits() (Duration, Duration, Duration) {
+	var (
+		TIME_LIMIT_WARNING  Duration = 20_000_000
+		TIME_LIMIT_ALERT    Duration = 35_000_000
+		TIME_LIMIT_CRITICAL Duration = 50_000_000
+	)
+
+	return TIME_LIMIT_WARNING, TIME_LIMIT_ALERT, TIME_LIMIT_CRITICAL
+}
+*/

components/api/operations/factory.go

@@ -8,6 +8,7 @@ func (factory *operationFactory) Operations() []IOperation {
 	return []IOperation{
 		SystemCallOperation(),
 		EchoOperation(),
+		CheckUsernameAvailabilityOperation(),
 		SignupOperation(),
 		VerifyOperation(),
 		LoginOperation(),

components/api/protobuf/spis.proto

@@ -25,6 +25,16 @@ message EchoResult {
     Document document = 0x00000001;
 }
 
+// API: CheckUsernameAvailability
+//-----------------------------------------------------------
+message CheckUsernameAvailabilityRequest {
+    string username = 0x00000001;
+}
+
+message CheckUsernameAvailabilityResult {
+    bool isAvailable = 0x00000001;
+}
+
 // API: Signup
 //-----------------------------------------------------------
 message SignupRequest {

components/api/services/check_username_availability_service.go

@@ -0,0 +1,29 @@
+package services
+
+import (
+	. "github.com/reiver/greatape/components/api/protobuf"
+	. "github.com/reiver/greatape/components/contracts"
+	"github.com/reiver/greatape/components/core"
+	. "github.com/xeronith/diamante/contracts/service"
+)
+
+// noinspection GoUnusedParameter
+func CheckUsernameAvailabilityService(context IContext, input *CheckUsernameAvailabilityRequest) (result *CheckUsernameAvailabilityResult, err error) {
+	conductor := core.Conductor
+	_ = CHECK_USERNAME_AVAILABILITY_REQUEST
+
+	conductor.LogRemoteCall(context, INITIALIZE, "check_username_availability", input, result, err)
+	defer func() { conductor.LogRemoteCall(context, FINALIZE, "check_username_availability", input, result, err) }()
+
+	_result, _err := conductor.CheckUsernameAvailability(input.Username, context.Identity())
+	if _err != nil {
+		err = _err
+		return nil, err
+	}
+
+	_ = _result
+
+	result = context.ResultContainer().(*CheckUsernameAvailabilityResult)
+	result.IsAvailable = _result.IsAvailable()
+	return result, nil
+}

components/constants/errors.go

@@ -8,54 +8,56 @@ const ENABLE_CUSTOM_ERRORS = true
 // noinspection GoSnakeCaseUsage
 const (
 	// SYSTEM_ERRORS
-	ERROR_MESSAGE_INITIALIZE                               = "ERROR_MESSAGE_INITIALIZE"
+	ERROR_MESSAGE_INITIALIZE                                       = "ERROR_MESSAGE_INITIALIZE"
-	ERROR_MESSAGE_NOT_IMPLEMENTED                          = "ERROR_MESSAGE_NOT_IMPLEMENTED"
+	ERROR_MESSAGE_NOT_IMPLEMENTED                                  = "ERROR_MESSAGE_NOT_IMPLEMENTED"
-	ERROR_MESSAGE_OPERATION_FAILED                         = "ERROR_MESSAGE_OPERATION_FAILED"
+	ERROR_MESSAGE_OPERATION_FAILED                                 = "ERROR_MESSAGE_OPERATION_FAILED"
-	ERROR_MESSAGE_OPERATION_NOT_SUPPORTED                  = "ERROR_MESSAGE_OPERATION_NOT_SUPPORTED"
+	ERROR_MESSAGE_OPERATION_NOT_SUPPORTED                          = "ERROR_MESSAGE_OPERATION_NOT_SUPPORTED"
-	ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES                  = "ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES"
+	ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES                          = "ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES"
-	ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND               = "ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND"
+	ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND                       = "ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND"
-	ERROR_MESSAGE_DOCUMENT_NOT_FOUND                       = "ERROR_MESSAGE_DOCUMENT_NOT_FOUND"
+	ERROR_MESSAGE_DOCUMENT_NOT_FOUND                               = "ERROR_MESSAGE_DOCUMENT_NOT_FOUND"
-	ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND                = "ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND"
+	ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND                        = "ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND"
-	ERROR_MESSAGE_IDENTITY_NOT_FOUND                       = "ERROR_MESSAGE_IDENTITY_NOT_FOUND"
+	ERROR_MESSAGE_IDENTITY_NOT_FOUND                               = "ERROR_MESSAGE_IDENTITY_NOT_FOUND"
-	ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND                 = "ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND"
+	ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND                         = "ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND"
-	ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND                = "ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND"
+	ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND                        = "ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND"
-	ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND                  = "ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND"
+	ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND                          = "ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND"
-	ERROR_MESSAGE_CATEGORY_NOT_FOUND                       = "ERROR_MESSAGE_CATEGORY_NOT_FOUND"
+	ERROR_MESSAGE_CATEGORY_NOT_FOUND                               = "ERROR_MESSAGE_CATEGORY_NOT_FOUND"
-	ERROR_MESSAGE_USER_NOT_FOUND                           = "ERROR_MESSAGE_USER_NOT_FOUND"
+	ERROR_MESSAGE_USER_NOT_FOUND                                   = "ERROR_MESSAGE_USER_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND            = "ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND                    = "ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND          = "ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND                  = "ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND        = "ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND                = "ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND              = "ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND                      = "ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND             = "ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND                     = "ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND = "ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND         = "ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND = "ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND         = "ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND"
-	ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND          = "ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND"
+	ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND                  = "ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND"
-	ERROR_MESSAGE_SPI_NOT_FOUND                            = "ERROR_MESSAGE_SPI_NOT_FOUND"
+	ERROR_MESSAGE_SPI_NOT_FOUND                                    = "ERROR_MESSAGE_SPI_NOT_FOUND"
-	ERROR_MESSAGE_UNKNOWN_DOCUMENT                         = "ERROR_MESSAGE_UNKNOWN_DOCUMENT"
+	ERROR_MESSAGE_UNKNOWN_DOCUMENT                                 = "ERROR_MESSAGE_UNKNOWN_DOCUMENT"
-	ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE                  = "ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE"
+	ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE                          = "ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE"
-	ERROR_MESSAGE_UNKNOWN_IDENTITY                         = "ERROR_MESSAGE_UNKNOWN_IDENTITY"
+	ERROR_MESSAGE_UNKNOWN_IDENTITY                                 = "ERROR_MESSAGE_UNKNOWN_IDENTITY"
-	ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL                   = "ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL"
+	ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL                           = "ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL"
-	ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY                  = "ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY"
+	ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY                          = "ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY"
-	ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE                    = "ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE"
+	ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE                            = "ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE"
-	ERROR_MESSAGE_UNKNOWN_CATEGORY                         = "ERROR_MESSAGE_UNKNOWN_CATEGORY"
+	ERROR_MESSAGE_UNKNOWN_CATEGORY                                 = "ERROR_MESSAGE_UNKNOWN_CATEGORY"
-	ERROR_MESSAGE_UNKNOWN_USER                             = "ERROR_MESSAGE_UNKNOWN_USER"
+	ERROR_MESSAGE_UNKNOWN_USER                                     = "ERROR_MESSAGE_UNKNOWN_USER"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT              = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT                      = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY            = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY                    = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY          = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY                  = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK                = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK                        = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA               = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA                       = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY   = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY           = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY   = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY           = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY"
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER            = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER"
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER                    = "ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER"
-	ERROR_MESSAGE_UNKNOWN_SPI                              = "ERROR_MESSAGE_UNKNOWN_SPI"
+	ERROR_MESSAGE_UNKNOWN_SPI                                      = "ERROR_MESSAGE_UNKNOWN_SPI"
-	ERROR_MESSAGE_INVALID_ID                               = "ERROR_MESSAGE_INVALID_ID"
+	ERROR_MESSAGE_INVALID_ID                                       = "ERROR_MESSAGE_INVALID_ID"
-	ERROR_MESSAGE_INVALID_PARAMETERS                       = "ERROR_MESSAGE_INVALID_PARAMETERS"
+	ERROR_MESSAGE_INVALID_PARAMETERS                               = "ERROR_MESSAGE_INVALID_PARAMETERS"
-	ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP                 = "ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP"
+	ERROR_MESSAGE_INVALID_USERNAME_FOR_CHECK_USERNAME_AVAILABILITY = "ERROR_MESSAGE_INVALID_USERNAME_FOR_CHECK_USERNAME_AVAILABILITY"
-	ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP              = "ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP"
+	ERROR_MESSAGE_INVALID_USERNAME_FOR_SIGNUP                      = "ERROR_MESSAGE_INVALID_USERNAME_FOR_SIGNUP"
-	ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY                 = "ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY"
+	ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP                         = "ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP"
-	ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN                  = "ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN"
+	ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP                      = "ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP"
-	ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN               = "ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN"
+	ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY                         = "ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY"
-	ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER           = "ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER"
+	ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN                          = "ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN"
+	ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN                       = "ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN"
+	ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER                   = "ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER"
 	// CUSTOM_ERRORS
 	ERROR_MESSAGE_DATA_INTEGRITY_VIOLATION             = "ERROR_MESSAGE_DATA_INTEGRITY_VIOLATION"
 	ERROR_MESSAGE_INVALID_STATE                        = "ERROR_MESSAGE_INVALID_STATE"
@@ -73,54 +75,56 @@ const (
 // noinspection GoSnakeCaseUsage,GoUnusedGlobalVariable
 var (
 	// SYSTEM_ERRORS
-	ERROR_INITIALIZE                               = errors.New(ERROR_MESSAGE_INITIALIZE)
+	ERROR_INITIALIZE                                       = errors.New(ERROR_MESSAGE_INITIALIZE)
-	ERROR_NOT_IMPLEMENTED                          = errors.New(ERROR_MESSAGE_NOT_IMPLEMENTED)
+	ERROR_NOT_IMPLEMENTED                                  = errors.New(ERROR_MESSAGE_NOT_IMPLEMENTED)
-	ERROR_OPERATION_FAILED                         = errors.New(ERROR_MESSAGE_OPERATION_FAILED)
+	ERROR_OPERATION_FAILED                                 = errors.New(ERROR_MESSAGE_OPERATION_FAILED)
-	ERROR_OPERATION_NOT_SUPPORTED                  = errors.New(ERROR_MESSAGE_OPERATION_NOT_SUPPORTED)
+	ERROR_OPERATION_NOT_SUPPORTED                          = errors.New(ERROR_MESSAGE_OPERATION_NOT_SUPPORTED)
-	ERROR_UNRESOLVED_DEPENDENCIES                  = errors.New(ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES)
+	ERROR_UNRESOLVED_DEPENDENCIES                          = errors.New(ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES)
-	ERROR_SYSTEM_COMPONENT_NOT_FOUND               = errors.New(ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND)
+	ERROR_SYSTEM_COMPONENT_NOT_FOUND                       = errors.New(ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND)
-	ERROR_DOCUMENT_NOT_FOUND                       = errors.New(ERROR_MESSAGE_DOCUMENT_NOT_FOUND)
+	ERROR_DOCUMENT_NOT_FOUND                               = errors.New(ERROR_MESSAGE_DOCUMENT_NOT_FOUND)
-	ERROR_SYSTEM_SCHEDULE_NOT_FOUND                = errors.New(ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND)
+	ERROR_SYSTEM_SCHEDULE_NOT_FOUND                        = errors.New(ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND)
-	ERROR_IDENTITY_NOT_FOUND                       = errors.New(ERROR_MESSAGE_IDENTITY_NOT_FOUND)
+	ERROR_IDENTITY_NOT_FOUND                               = errors.New(ERROR_MESSAGE_IDENTITY_NOT_FOUND)
-	ERROR_ACCESS_CONTROL_NOT_FOUND                 = errors.New(ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND)
+	ERROR_ACCESS_CONTROL_NOT_FOUND                         = errors.New(ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND)
-	ERROR_REMOTE_ACTIVITY_NOT_FOUND                = errors.New(ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND)
+	ERROR_REMOTE_ACTIVITY_NOT_FOUND                        = errors.New(ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND)
-	ERROR_CATEGORY_TYPE_NOT_FOUND                  = errors.New(ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND)
+	ERROR_CATEGORY_TYPE_NOT_FOUND                          = errors.New(ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND)
-	ERROR_CATEGORY_NOT_FOUND                       = errors.New(ERROR_MESSAGE_CATEGORY_NOT_FOUND)
+	ERROR_CATEGORY_NOT_FOUND                               = errors.New(ERROR_MESSAGE_CATEGORY_NOT_FOUND)
-	ERROR_USER_NOT_FOUND                           = errors.New(ERROR_MESSAGE_USER_NOT_FOUND)
+	ERROR_USER_NOT_FOUND                                   = errors.New(ERROR_MESSAGE_USER_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_OBJECT_NOT_FOUND            = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_OBJECT_NOT_FOUND                    = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_ACTIVITY_NOT_FOUND          = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_ACTIVITY_NOT_FOUND                  = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND        = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND                = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_LINK_NOT_FOUND              = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_LINK_NOT_FOUND                      = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_MEDIA_NOT_FOUND             = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_MEDIA_NOT_FOUND                     = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND         = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND         = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND)
-	ERROR_ACTIVITY_PUB_FOLLOWER_NOT_FOUND          = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND)
+	ERROR_ACTIVITY_PUB_FOLLOWER_NOT_FOUND                  = errors.New(ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND)
-	ERROR_SPI_NOT_FOUND                            = errors.New(ERROR_MESSAGE_SPI_NOT_FOUND)
+	ERROR_SPI_NOT_FOUND                                    = errors.New(ERROR_MESSAGE_SPI_NOT_FOUND)
-	ERROR_UNKNOWN_DOCUMENT                         = errors.New(ERROR_MESSAGE_UNKNOWN_DOCUMENT)
+	ERROR_UNKNOWN_DOCUMENT                                 = errors.New(ERROR_MESSAGE_UNKNOWN_DOCUMENT)
-	ERROR_UNKNOWN_SYSTEM_SCHEDULE                  = errors.New(ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE)
+	ERROR_UNKNOWN_SYSTEM_SCHEDULE                          = errors.New(ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE)
-	ERROR_UNKNOWN_IDENTITY                         = errors.New(ERROR_MESSAGE_UNKNOWN_IDENTITY)
+	ERROR_UNKNOWN_IDENTITY                                 = errors.New(ERROR_MESSAGE_UNKNOWN_IDENTITY)
-	ERROR_UNKNOWN_ACCESS_CONTROL                   = errors.New(ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL)
+	ERROR_UNKNOWN_ACCESS_CONTROL                           = errors.New(ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL)
-	ERROR_UNKNOWN_REMOTE_ACTIVITY                  = errors.New(ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY)
+	ERROR_UNKNOWN_REMOTE_ACTIVITY                          = errors.New(ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY)
-	ERROR_UNKNOWN_CATEGORY_TYPE                    = errors.New(ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE)
+	ERROR_UNKNOWN_CATEGORY_TYPE                            = errors.New(ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE)
-	ERROR_UNKNOWN_CATEGORY                         = errors.New(ERROR_MESSAGE_UNKNOWN_CATEGORY)
+	ERROR_UNKNOWN_CATEGORY                                 = errors.New(ERROR_MESSAGE_UNKNOWN_CATEGORY)
-	ERROR_UNKNOWN_USER                             = errors.New(ERROR_MESSAGE_UNKNOWN_USER)
+	ERROR_UNKNOWN_USER                                     = errors.New(ERROR_MESSAGE_UNKNOWN_USER)
-	ERROR_UNKNOWN_ACTIVITY_PUB_OBJECT              = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT)
+	ERROR_UNKNOWN_ACTIVITY_PUB_OBJECT                      = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT)
-	ERROR_UNKNOWN_ACTIVITY_PUB_ACTIVITY            = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY)
+	ERROR_UNKNOWN_ACTIVITY_PUB_ACTIVITY                    = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY)
-	ERROR_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY          = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY)
+	ERROR_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY                  = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY)
-	ERROR_UNKNOWN_ACTIVITY_PUB_LINK                = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK)
+	ERROR_UNKNOWN_ACTIVITY_PUB_LINK                        = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK)
-	ERROR_UNKNOWN_ACTIVITY_PUB_MEDIA               = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA)
+	ERROR_UNKNOWN_ACTIVITY_PUB_MEDIA                       = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA)
-	ERROR_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY   = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY)
+	ERROR_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY           = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY)
-	ERROR_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY   = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY)
+	ERROR_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY           = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY)
-	ERROR_UNKNOWN_ACTIVITY_PUB_FOLLOWER            = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER)
+	ERROR_UNKNOWN_ACTIVITY_PUB_FOLLOWER                    = errors.New(ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER)
-	ERROR_UNKNOWN_SPI                              = errors.New(ERROR_MESSAGE_UNKNOWN_SPI)
+	ERROR_UNKNOWN_SPI                                      = errors.New(ERROR_MESSAGE_UNKNOWN_SPI)
-	ERROR_INVALID_ID                               = errors.New(ERROR_MESSAGE_INVALID_ID)
+	ERROR_INVALID_ID                                       = errors.New(ERROR_MESSAGE_INVALID_ID)
-	ERROR_INVALID_PARAMETERS                       = errors.New(ERROR_MESSAGE_INVALID_PARAMETERS)
+	ERROR_INVALID_PARAMETERS                               = errors.New(ERROR_MESSAGE_INVALID_PARAMETERS)
-	ERROR_INVALID_EMAIL_FOR_SIGNUP                 = errors.New(ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP)
+	ERROR_INVALID_USERNAME_FOR_CHECK_USERNAME_AVAILABILITY = errors.New(ERROR_MESSAGE_INVALID_USERNAME_FOR_CHECK_USERNAME_AVAILABILITY)
-	ERROR_INVALID_PASSWORD_FOR_SIGNUP              = errors.New(ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP)
+	ERROR_INVALID_USERNAME_FOR_SIGNUP                      = errors.New(ERROR_MESSAGE_INVALID_USERNAME_FOR_SIGNUP)
-	ERROR_INVALID_EMAIL_FOR_VERIFY                 = errors.New(ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY)
+	ERROR_INVALID_EMAIL_FOR_SIGNUP                         = errors.New(ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP)
-	ERROR_INVALID_EMAIL_FOR_LOGIN                  = errors.New(ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN)
+	ERROR_INVALID_PASSWORD_FOR_SIGNUP                      = errors.New(ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP)
-	ERROR_INVALID_PASSWORD_FOR_LOGIN               = errors.New(ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN)
+	ERROR_INVALID_EMAIL_FOR_VERIFY                         = errors.New(ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY)
-	ERROR_INVALID_RESOURCE_FOR_WEBFINGER           = errors.New(ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER)
+	ERROR_INVALID_EMAIL_FOR_LOGIN                          = errors.New(ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN)
+	ERROR_INVALID_PASSWORD_FOR_LOGIN                       = errors.New(ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN)
+	ERROR_INVALID_RESOURCE_FOR_WEBFINGER                   = errors.New(ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER)
 	// CUSTOM_ERRORS
 	ERROR_DATA_INTEGRITY_VIOLATION             = errors.New(ERROR_MESSAGE_DATA_INTEGRITY_VIOLATION)
 	ERROR_INVALID_STATE                        = errors.New(ERROR_MESSAGE_INVALID_STATE)

components/constants/resources.en-US.go

@@ -5,54 +5,56 @@ import . "github.com/xeronith/diamante/contracts/localization"
 // noinspection GoUnusedGlobalVariable
 var Errors = Resource{
 	// SYSTEM_ERRORS
-	ERROR_MESSAGE_INITIALIZE:                               "initialize",
+	ERROR_MESSAGE_INITIALIZE:                                       "initialize",
-	ERROR_MESSAGE_NOT_IMPLEMENTED:                          "not_implemented",
+	ERROR_MESSAGE_NOT_IMPLEMENTED:                                  "not_implemented",
-	ERROR_MESSAGE_OPERATION_FAILED:                         "operation_failed",
+	ERROR_MESSAGE_OPERATION_FAILED:                                 "operation_failed",
-	ERROR_MESSAGE_OPERATION_NOT_SUPPORTED:                  "operation_not_supported",
+	ERROR_MESSAGE_OPERATION_NOT_SUPPORTED:                          "operation_not_supported",
-	ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES:                  "unresolved_dependencies",
+	ERROR_MESSAGE_UNRESOLVED_DEPENDENCIES:                          "unresolved_dependencies",
-	ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND:               "system_component_not_found",
+	ERROR_MESSAGE_SYSTEM_COMPONENT_NOT_FOUND:                       "system_component_not_found",
-	ERROR_MESSAGE_DOCUMENT_NOT_FOUND:                       "document_not_found",
+	ERROR_MESSAGE_DOCUMENT_NOT_FOUND:                               "document_not_found",
-	ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND:                "system_schedule_not_found",
+	ERROR_MESSAGE_SYSTEM_SCHEDULE_NOT_FOUND:                        "system_schedule_not_found",
-	ERROR_MESSAGE_IDENTITY_NOT_FOUND:                       "identity_not_found",
+	ERROR_MESSAGE_IDENTITY_NOT_FOUND:                               "identity_not_found",
-	ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND:                 "access_control_not_found",
+	ERROR_MESSAGE_ACCESS_CONTROL_NOT_FOUND:                         "access_control_not_found",
-	ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND:                "remote_activity_not_found",
+	ERROR_MESSAGE_REMOTE_ACTIVITY_NOT_FOUND:                        "remote_activity_not_found",
-	ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND:                  "category_type_not_found",
+	ERROR_MESSAGE_CATEGORY_TYPE_NOT_FOUND:                          "category_type_not_found",
-	ERROR_MESSAGE_CATEGORY_NOT_FOUND:                       "category_not_found",
+	ERROR_MESSAGE_CATEGORY_NOT_FOUND:                               "category_not_found",
-	ERROR_MESSAGE_USER_NOT_FOUND:                           "user_not_found",
+	ERROR_MESSAGE_USER_NOT_FOUND:                                   "user_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND:            "activity_pub_object_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_OBJECT_NOT_FOUND:                    "activity_pub_object_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND:          "activity_pub_activity_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_ACTIVITY_NOT_FOUND:                  "activity_pub_activity_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND:        "activity_pub_public_key_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_PUBLIC_KEY_NOT_FOUND:                "activity_pub_public_key_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND:              "activity_pub_link_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_LINK_NOT_FOUND:                      "activity_pub_link_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND:             "activity_pub_media_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_MEDIA_NOT_FOUND:                     "activity_pub_media_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND: "activity_pub_incoming_activity_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_INCOMING_ACTIVITY_NOT_FOUND:         "activity_pub_incoming_activity_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND: "activity_pub_outgoing_activity_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_OUTGOING_ACTIVITY_NOT_FOUND:         "activity_pub_outgoing_activity_not_found",
-	ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND:          "activity_pub_follower_not_found",
+	ERROR_MESSAGE_ACTIVITY_PUB_FOLLOWER_NOT_FOUND:                  "activity_pub_follower_not_found",
-	ERROR_MESSAGE_SPI_NOT_FOUND:                            "spi_not_found",
+	ERROR_MESSAGE_SPI_NOT_FOUND:                                    "spi_not_found",
-	ERROR_MESSAGE_UNKNOWN_DOCUMENT:                         "unknown_document",
+	ERROR_MESSAGE_UNKNOWN_DOCUMENT:                                 "unknown_document",
-	ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE:                  "unknown_system_schedule",
+	ERROR_MESSAGE_UNKNOWN_SYSTEM_SCHEDULE:                          "unknown_system_schedule",
-	ERROR_MESSAGE_UNKNOWN_IDENTITY:                         "unknown_identity",
+	ERROR_MESSAGE_UNKNOWN_IDENTITY:                                 "unknown_identity",
-	ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL:                   "unknown_access_control",
+	ERROR_MESSAGE_UNKNOWN_ACCESS_CONTROL:                           "unknown_access_control",
-	ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY:                  "unknown_remote_activity",
+	ERROR_MESSAGE_UNKNOWN_REMOTE_ACTIVITY:                          "unknown_remote_activity",
-	ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE:                    "unknown_category_type",
+	ERROR_MESSAGE_UNKNOWN_CATEGORY_TYPE:                            "unknown_category_type",
-	ERROR_MESSAGE_UNKNOWN_CATEGORY:                         "unknown_category",
+	ERROR_MESSAGE_UNKNOWN_CATEGORY:                                 "unknown_category",
-	ERROR_MESSAGE_UNKNOWN_USER:                             "unknown_user",
+	ERROR_MESSAGE_UNKNOWN_USER:                                     "unknown_user",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT:              "unknown_activity_pub_object",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OBJECT:                      "unknown_activity_pub_object",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY:            "unknown_activity_pub_activity",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_ACTIVITY:                    "unknown_activity_pub_activity",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY:          "unknown_activity_pub_public_key",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_PUBLIC_KEY:                  "unknown_activity_pub_public_key",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK:                "unknown_activity_pub_link",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_LINK:                        "unknown_activity_pub_link",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA:               "unknown_activity_pub_media",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_MEDIA:                       "unknown_activity_pub_media",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY:   "unknown_activity_pub_incoming_activity",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_INCOMING_ACTIVITY:           "unknown_activity_pub_incoming_activity",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY:   "unknown_activity_pub_outgoing_activity",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_OUTGOING_ACTIVITY:           "unknown_activity_pub_outgoing_activity",
-	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER:            "unknown_activity_pub_follower",
+	ERROR_MESSAGE_UNKNOWN_ACTIVITY_PUB_FOLLOWER:                    "unknown_activity_pub_follower",
-	ERROR_MESSAGE_UNKNOWN_SPI:                              "unknown_spi",
+	ERROR_MESSAGE_UNKNOWN_SPI:                                      "unknown_spi",
-	ERROR_MESSAGE_INVALID_ID:                               "invalid_id",
+	ERROR_MESSAGE_INVALID_ID:                                       "invalid_id",
-	ERROR_MESSAGE_INVALID_PARAMETERS:                       "invalid_parameters",
+	ERROR_MESSAGE_INVALID_PARAMETERS:                               "invalid_parameters",
-	ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP:                 "invalid_email",
+	ERROR_MESSAGE_INVALID_USERNAME_FOR_CHECK_USERNAME_AVAILABILITY: "invalid_username",
-	ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP:              "invalid_password",
+	ERROR_MESSAGE_INVALID_USERNAME_FOR_SIGNUP:                      "invalid_username",
-	ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY:                 "invalid_email",
+	ERROR_MESSAGE_INVALID_EMAIL_FOR_SIGNUP:                         "invalid_email",
-	ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN:                  "invalid_email",
+	ERROR_MESSAGE_INVALID_PASSWORD_FOR_SIGNUP:                      "invalid_password",
-	ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN:               "invalid_password",
+	ERROR_MESSAGE_INVALID_EMAIL_FOR_VERIFY:                         "invalid_email",
-	ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER:           "invalid_resource",
+	ERROR_MESSAGE_INVALID_EMAIL_FOR_LOGIN:                          "invalid_email",
+	ERROR_MESSAGE_INVALID_PASSWORD_FOR_LOGIN:                       "invalid_password",
+	ERROR_MESSAGE_INVALID_RESOURCE_FOR_WEBFINGER:                   "invalid_resource",
 	// CUSTOM_ERRORS
 	ERROR_MESSAGE_DATA_INTEGRITY_VIOLATION:             "data_integrity_violation",
 	ERROR_MESSAGE_INVALID_STATE:                        "invalid_state",

components/contracts/api.go

@@ -8,6 +8,7 @@ type IApi interface {
 	//API Methods
 	SystemCall(*SystemCallRequest) (*SystemCallResult, error)
 	Echo(*EchoRequest) (*EchoResult, error)
+	CheckUsernameAvailability(*CheckUsernameAvailabilityRequest) (*CheckUsernameAvailabilityResult, error)
 	Signup(*SignupRequest) (*SignupResult, error)
 	Verify(*VerifyRequest) (*VerifyResult, error)
 	Login(*LoginRequest) (*LoginResult, error)

components/contracts/opcodes.go

@@ -12,6 +12,10 @@ const (
 	ECHO_REQUEST = 0x0541BD72
 	ECHO_RESULT  = 0xAB2FF7D4
 
+	//CheckUsernameAvailabilityOperation
+	CHECK_USERNAME_AVAILABILITY_REQUEST = 0xA9501A55
+	CHECK_USERNAME_AVAILABILITY_RESULT  = 0x067190FF
+
 	//SignupOperation
 	SIGNUP_REQUEST = 0x48DB23BF
 	SIGNUP_RESULT  = 0x83D062B4
@@ -85,6 +89,8 @@ var OPCODES = Opcodes{
 	0x00000000: "N/A",
 	0x0541BD72: "ECHO",
 	0xAB2FF7D4: "Echo",
+	0xA9501A55: "CHECK_USERNAME_AVAILABILITY",
+	0x067190FF: "CheckUsernameAvailability",
 	0x48DB23BF: "SIGNUP",
 	0x83D062B4: "Signup",
 	0x8B78F7F6: "VERIFY",

components/contracts/spi.go

@@ -56,6 +56,7 @@ type (
 		Filter(predicate SpiFilterPredicate) ISpiCollection
 		Map(predicate SpiMapPredicate) ISpiCollection
 		Echo(document IDocument, editor Identity) (IEchoResult, error)
+		CheckUsernameAvailability(username string, editor Identity) (ICheckUsernameAvailabilityResult, error)
 		Signup(username string, email string, password string, editor Identity) (ISignupResult, error)
 		Verify(email string, token string, code string, editor Identity) (IVerifyResult, error)
 		Login(email string, password string, editor Identity) (ILoginResult, error)
@@ -79,6 +80,10 @@ type (
 		Document() IDocument
 	}
 
+	ICheckUsernameAvailabilityResult interface {
+		IsAvailable() bool
+	}
+
 	ISignupResult interface {
 		Token() string
 		Code() string

components/contracts/system_component.go

@@ -258,6 +258,7 @@ type (
 		RemoveSpi(id int64, editor Identity) (ISpi, error)
 		RemoveSpiAtomic(transaction ITransaction, id int64, editor Identity) (ISpi, error)
 		Echo(document IDocument, editor Identity) (IEchoResult, error)
+		CheckUsernameAvailability(username string, editor Identity) (ICheckUsernameAvailabilityResult, error)
 		Signup(username string, email string, password string, editor Identity) (ISignupResult, error)
 		Verify(email string, token string, code string, editor Identity) (IVerifyResult, error)
 		Login(email string, password string, editor Identity) (ILoginResult, error)
@@ -294,6 +295,7 @@ type (
 		NewActivityPubFollower(id int64, handle string, inbox string, subject string, activity string, accepted bool) (IActivityPubFollower, error)
 		NewSpi() (ISpi, error)
 		NewEchoResult(document IDocument, ignored interface{}) IEchoResult
+		NewCheckUsernameAvailabilityResult(isAvailable bool, ignored interface{}) ICheckUsernameAvailabilityResult
 		NewSignupResult(token string, code string, ignored interface{}) ISignupResult
 		NewVerifyResult(token string, ignored interface{}) IVerifyResult
 		NewLoginResult(username string, token string, ignored interface{}) ILoginResult

components/contracts/system_dispatcher.go

@@ -1033,6 +1033,7 @@ type IDispatcher interface {
 	// the transaction if used in an x.Atomic context. This method is synchronous.
 	RemoveSpi(id int64) ISpi
 	Echo(document IDocument) (IEchoResult, error)
+	CheckUsernameAvailability(username string) (ICheckUsernameAvailabilityResult, error)
 	Signup(username string, email string, password string) (ISignupResult, error)
 	Verify(email string, token string, code string) (IVerifyResult, error)
 	Login(email string, password string) (ILoginResult, error)
@@ -1121,6 +1122,8 @@ type IDispatcher interface {
 	NewSpis() ISpiCollection
 	// NewEchoResult creates a new result container for 'Echo' system action.
 	NewEchoResult(document IDocument) IEchoResult
+	// NewCheckUsernameAvailabilityResult creates a new result container for 'Check Username Availability' system action.
+	NewCheckUsernameAvailabilityResult(isAvailable bool) ICheckUsernameAvailabilityResult
 	// NewSignupResult creates a new result container for 'Signup' system action.
 	NewSignupResult(token string, code string) ISignupResult
 	// NewVerifyResult creates a new result container for 'Verify' system action.

components/core/api_methods.go

@@ -25,6 +25,16 @@ func (api *api) Echo(request *EchoRequest) (*EchoResult, error) {
 	}
 }
 
+func (api *api) CheckUsernameAvailability(request *CheckUsernameAvailabilityRequest) (*CheckUsernameAvailabilityResult, error) {
+	result, err := api.call(CHECK_USERNAME_AVAILABILITY_REQUEST, request)
+
+	if err != nil {
+		return nil, err
+	} else {
+		return result.(*CheckUsernameAvailabilityResult), nil
+	}
+}
+
 func (api *api) Signup(request *SignupRequest) (*SignupResult, error) {
 	result, err := api.call(SIGNUP_REQUEST, request)
 
@@ -198,6 +208,7 @@ func (api *api) GetInbox(request *GetInboxRequest) (*GetInboxResult, error) {
 func init() {
 	API_RESULT[SYSTEM_CALL_RESULT] = SystemCallResult{}
 	API_RESULT[ECHO_RESULT] = EchoResult{}
+	API_RESULT[CHECK_USERNAME_AVAILABILITY_RESULT] = CheckUsernameAvailabilityResult{}
 	API_RESULT[SIGNUP_RESULT] = SignupResult{}
 	API_RESULT[VERIFY_RESULT] = VerifyResult{}
 	API_RESULT[LOGIN_RESULT] = LoginResult{}

components/core/initializer.go

@@ -1099,6 +1099,10 @@ func (conductor *conductor) Echo(document IDocument, editor Identity) (IEchoResu
 	return conductor.spiManager.Echo(document, editor)
 }
 
+func (conductor *conductor) CheckUsernameAvailability(username string, editor Identity) (ICheckUsernameAvailabilityResult, error) {
+	return conductor.spiManager.CheckUsernameAvailability(username, editor)
+}
+
 func (conductor *conductor) Signup(username string, email string, password string, editor Identity) (ISignupResult, error) {
 	return conductor.spiManager.Signup(username, email, password, editor)
 }
@@ -1239,6 +1243,10 @@ func (conductor *conductor) NewEchoResult(document IDocument, _ interface{}) IEc
 	return NewEchoResult(document, nil)
 }
 
+func (conductor *conductor) NewCheckUsernameAvailabilityResult(isAvailable bool, _ interface{}) ICheckUsernameAvailabilityResult {
+	return NewCheckUsernameAvailabilityResult(isAvailable, nil)
+}
+
 func (conductor *conductor) NewSignupResult(token string, code string, _ interface{}) ISignupResult {
 	return NewSignupResult(token, code, nil)
 }

components/core/spi.go

@@ -256,6 +256,10 @@ func (dispatcher *dispatcher) Echo(document IDocument) (IEchoResult, error) {
 	return dispatcher.conductor.SpiManager().Echo(document, dispatcher.identity)
 }
 
+func (dispatcher *dispatcher) CheckUsernameAvailability(username string) (ICheckUsernameAvailabilityResult, error) {
+	return dispatcher.conductor.SpiManager().CheckUsernameAvailability(username, dispatcher.identity)
+}
+
 func (dispatcher *dispatcher) Signup(username string, email string, password string) (ISignupResult, error) {
 	return dispatcher.conductor.SpiManager().Signup(username, email, password, dispatcher.identity)
 }

components/core/spi_manager.go

@@ -231,6 +231,45 @@ func (manager *spiManager) Echo(document IDocument, editor Identity) (result IEc
 	}
 }
 
+//region ICheckUsernameAvailabilityResult Implementation
+
+type checkUsernameAvailabilityResult struct {
+	isAvailable bool
+}
+
+func NewCheckUsernameAvailabilityResult(isAvailable bool, _ interface{}) ICheckUsernameAvailabilityResult {
+	return &checkUsernameAvailabilityResult{
+		isAvailable: isAvailable,
+	}
+}
+
+func (result checkUsernameAvailabilityResult) IsAvailable() bool {
+	return result.isAvailable
+}
+
+//endregion
+
+func (manager *spiManager) CheckUsernameAvailability(username string, editor Identity) (result ICheckUsernameAvailabilityResult, err error) {
+	if !validators.UsernameIsValid(username) {
+		return nil, ERROR_INVALID_USERNAME_FOR_CHECK_USERNAME_AVAILABILITY
+	}
+
+	defer func() {
+		if reason := recover(); reason != nil {
+			err = manager.Error(reason)
+		}
+	}()
+
+	editor.Lock(CHECK_USERNAME_AVAILABILITY_REQUEST)
+	defer editor.Unlock(CHECK_USERNAME_AVAILABILITY_REQUEST)
+
+	if result, err = commands.CheckUsernameAvailability(NewDispatcher(Conductor, editor), username); err != nil {
+		return nil, err
+	} else {
+		return result, nil
+	}
+}
+
 //region ISignupResult Implementation
 
 type signupResult struct {
@@ -264,6 +303,10 @@ func (manager *spiManager) Signup(username string, email string, password string
 		}
 	}
 
+	if !validators.UsernameIsValid(username) {
+		return nil, ERROR_INVALID_USERNAME_FOR_SIGNUP
+	}
+
 	if !validators.PasswordIsValid(password) {
 		return nil, ERROR_INVALID_PASSWORD_FOR_SIGNUP
 	}

components/core/spi_manager_test.go

@@ -160,6 +160,17 @@ func TestSpiManager_Echo(test *testing.T) {
 	_ = result
 }
 
+func TestSpiManager_CheckUsernameAvailability(test *testing.T) {
+	manager := Conductor.SpiManager()
+
+	result, err := manager.CheckUsernameAvailability("username", nil)
+	if err != nil {
+		test.Fatal(err)
+	}
+
+	_ = result
+}
+
 func TestSpiManager_Signup(test *testing.T) {
 	manager := Conductor.SpiManager()
 

components/core/system_results.go

@@ -8,6 +8,10 @@ func (dispatcher *dispatcher) NewEchoResult(document IDocument) IEchoResult {
 	return NewEchoResult(document, nil)
 }
 
+func (dispatcher *dispatcher) NewCheckUsernameAvailabilityResult(isAvailable bool) ICheckUsernameAvailabilityResult {
+	return NewCheckUsernameAvailabilityResult(isAvailable, nil)
+}
+
 func (dispatcher *dispatcher) NewSignupResult(token string, code string) ISignupResult {
 	return NewSignupResult(token, code, nil)
 }