refactor: remove rolename from invitations table

Signed-off-by: Felix Gateru <[email protected]>

domains/api/http/invitations.go

@@ -121,10 +121,6 @@ func decodeListInvitationsReq(_ context.Context, r *http.Request) (interface{},
 	if err != nil {
 		return nil, errors.Wrap(apiutil.ErrValidation, err)
 	}
-	roleName, err := apiutil.ReadStringQuery(r, roleNameKey, "")
-	if err != nil {
-		return nil, errors.Wrap(apiutil.ErrValidation, err)
-	}
 	domainID, err := apiutil.ReadStringQuery(r, domainIDKey, "")
 	if err != nil {
 		return nil, errors.Wrap(apiutil.ErrValidation, err)
@@ -144,7 +140,6 @@ func decodeListInvitationsReq(_ context.Context, r *http.Request) (interface{},
 			InvitedBy: invitedBy,
 			UserID:    userID,
 			RoleID:    roleID,
-			RoleName:  roleName,
 			DomainID:  domainID,
 			State:     state,
 		},

domains/events/events.go

@@ -357,9 +357,6 @@ func (lie listInvitationsEvent) Encode() (map[string]interface{}, error) {
 	if lie.RoleID != "" {
 		val["role_id"] = lie.RoleID
 	}
-	if lie.RoleName != "" {
-		val["role_name"] = lie.RoleName
-	}
 	if lie.State.String() != "" {
 		val["state"] = lie.State.String()
 	}

domains/invitations.go

@@ -52,7 +52,6 @@ type InvitationPageMeta struct {
 	UserID            string `json:"user_id,omitempty" db:"user_id,omitempty"`
 	DomainID          string `json:"domain_id,omitempty" db:"domain_id,omitempty"`
 	RoleID            string `json:"role_id,omitempty" db:"role_id,omitempty"`
-	RoleName          string `json:"role_name,omitempty" db:"role_name,omitempty"`
 	InvitedByOrUserID string `db:"invited_by_or_user_id,omitempty"`
 	State             State  `json:"state,omitempty"`
 }

domains/postgres/init.go

@@ -48,7 +48,6 @@ func Migration() (*migrate.MemoryMigrationSource, error) {
 						user_id         VARCHAR(36) NOT NULL,
 						domain_id       VARCHAR(36) NOT NULL,
 						role_id         VARCHAR(36) NOT NULL,
-						role_name       VARCHAR(200),
 						created_at      TIMESTAMP NOT NULL,
 						updated_at      TIMESTAMP,
 						confirmed_at    TIMESTAMP,

domains/postgres/invitations.go

@@ -16,8 +16,8 @@ import (
 )
 
 func (repo domainRepo) SaveInvitation(ctx context.Context, invitation domains.Invitation) (err error) {
-	q := `INSERT INTO invitations (invited_by, user_id, domain_id, role_id, role_name, created_at)
-		VALUES (:invited_by, :user_id, :domain_id, :role_id, :role_name, :created_at)`
+	q := `INSERT INTO invitations (invited_by, user_id, domain_id, role_id, created_at)
+		VALUES (:invited_by, :user_id, :domain_id, :role_id, :created_at)`
 
 	dbInv := toDBInvitation(invitation)
 	if _, err = repo.db.NamedExecContext(ctx, q, dbInv); err != nil {
@@ -28,7 +28,7 @@ func (repo domainRepo) SaveInvitation(ctx context.Context, invitation domains.In
 }
 
 func (repo domainRepo) RetrieveInvitation(ctx context.Context, userID, domainID string) (domains.Invitation, error) {
-	q := `SELECT invited_by, user_id, domain_id, role_id, role_name, created_at, updated_at, confirmed_at, rejected_at FROM invitations WHERE user_id = :user_id AND domain_id = :domain_id;`
+	q := `SELECT invited_by, user_id, domain_id, role_id, created_at, updated_at, confirmed_at, rejected_at FROM invitations WHERE user_id = :user_id AND domain_id = :domain_id;`
 
 	dbinv := dbInvitation{
 		UserID:   userID,
@@ -55,7 +55,7 @@ func (repo domainRepo) RetrieveInvitation(ctx context.Context, userID, domainID
 func (repo domainRepo) RetrieveAllInvitations(ctx context.Context, pm domains.InvitationPageMeta) (domains.InvitationPage, error) {
 	query := pageQuery(pm)
 
-	q := fmt.Sprintf("SELECT invited_by, user_id, domain_id, role_id, role_name, created_at, updated_at, confirmed_at, rejected_at FROM invitations %s LIMIT :limit OFFSET :offset;", query)
+	q := fmt.Sprintf("SELECT invited_by, user_id, domain_id, role_id, created_at, updated_at, confirmed_at, rejected_at FROM invitations %s LIMIT :limit OFFSET :offset;", query)
 
 	rows, err := repo.db.NamedQueryContext(ctx, q, pm)
 	if err != nil {
@@ -148,9 +148,6 @@ func pageQuery(pm domains.InvitationPageMeta) string {
 	if pm.RoleID != "" {
 		query = append(query, "role_id = :role_id")
 	}
-	if pm.RoleName != "" {
-		query = append(query, "role_name = :role_name")
-	}
 	if pm.InvitedByOrUserID != "" {
 		query = append(query, "(invited_by = :invited_by_or_user_id OR user_id = :invited_by_or_user_id)")
 	}
@@ -176,7 +173,6 @@ type dbInvitation struct {
 	UserID      string       `db:"user_id"`
 	DomainID    string       `db:"domain_id"`
 	RoleID      string       `db:"role_id,omitempty"`
-	RoleName    string       `db:"role_name,omitempty"`
 	Relation    string       `db:"relation"`
 	CreatedAt   time.Time    `db:"created_at"`
 	UpdatedAt   sql.NullTime `db:"updated_at,omitempty"`
@@ -201,7 +197,6 @@ func toDBInvitation(inv domains.Invitation) dbInvitation {
 		UserID:      inv.UserID,
 		DomainID:    inv.DomainID,
 		RoleID:      inv.RoleID,
-		RoleName:    inv.RoleName,
 		CreatedAt:   inv.CreatedAt,
 		UpdatedAt:   updatedAt,
 		ConfirmedAt: confirmedAt,
@@ -226,7 +221,6 @@ func toInvitation(dbinv dbInvitation) domains.Invitation {
 		UserID:      dbinv.UserID,
 		DomainID:    dbinv.DomainID,
 		RoleID:      dbinv.RoleID,
-		RoleName:    dbinv.RoleName,
 		CreatedAt:   dbinv.CreatedAt,
 		UpdatedAt:   updatedAt,
 		ConfirmedAt: confirmedAt,

domains/service.go

@@ -178,12 +178,9 @@ func (svc service) ListDomains(ctx context.Context, session authn.Session, p Pag
 }
 
 func (svc *service) SendInvitation(ctx context.Context, session authn.Session, invitation Invitation) error {
-	role, err := svc.repo.RetrieveRole(ctx, invitation.RoleID)
-	if err != nil {
+	if _, err := svc.repo.RetrieveRole(ctx, invitation.RoleID); err != nil {
 		return errors.Wrap(svcerr.ErrInvalidRole, err)
 	}
-	invitation.RoleName = role.Name
-
 	invitation.InvitedBy = session.UserID
 
 	invitation.CreatedAt = time.Now()
@@ -199,11 +196,16 @@ func (svc *service) ViewInvitation(ctx context.Context, session authn.Session, u
 	if err != nil {
 		return Invitation{}, errors.Wrap(svcerr.ErrViewEntity, err)
 	}
+	role, err := svc.repo.RetrieveRole(ctx, inv.RoleID)
+	if err != nil {
+		return Invitation{}, errors.Wrap(svcerr.ErrViewEntity, err)
+	}
 	actions, err := svc.repo.RoleListActions(ctx, inv.RoleID)
 	if err != nil {
 		return Invitation{}, errors.Wrap(svcerr.ErrViewEntity, err)
 	}
 	inv.Actions = actions
+	inv.RoleName = role.Name
 
 	return inv, nil
 }

domains/service_test.go

@@ -628,7 +628,6 @@ func TestViewInvitation(t *testing.T) {
 		UserID:      testsutil.GenerateUUID(t),
 		DomainID:    testsutil.GenerateUUID(t),
 		RoleID:      testsutil.GenerateUUID(t),
-		RoleName:    "admin",
 		Actions:     []string{"read", "delete"},
 		CreatedAt:   time.Now().Add(-time.Hour),
 		UpdatedAt:   time.Now().Add(-time.Hour),
@@ -643,6 +642,7 @@ func TestViewInvitation(t *testing.T) {
 		resp                  domains.Invitation
 		retrieveInvitationErr error
 		listRolesErr          error
+		retrieveRoleErr       error
 		err                   error
 	}{
 		{
@@ -669,17 +669,27 @@ func TestViewInvitation(t *testing.T) {
 			listRolesErr: repoerr.ErrNotFound,
 			err:          svcerr.ErrViewEntity,
 		},
+		{
+			desc:            "view invitation with failed to retrieve role",
+			userID:          validInvitation.UserID,
+			domainID:        validInvitation.DomainID,
+			session:         validSession,
+			retrieveRoleErr: repoerr.ErrNotFound,
+			err:             svcerr.ErrViewEntity,
+		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			repoCall := drepo.On("RetrieveInvitation", context.Background(), mock.Anything, mock.Anything).Return(tc.resp, tc.retrieveInvitationErr)
 			repoCall1 := drepo.On("RoleListActions", context.Background(), tc.resp.RoleID).Return(tc.resp.Actions, tc.listRolesErr)
+			repoCall2 := drepo.On("RetrieveRole", context.Background(), tc.resp.RoleID).Return(roles.Role{}, tc.retrieveRoleErr)
 			inv, err := svc.ViewInvitation(context.Background(), tc.session, tc.userID, tc.domainID)
 			assert.True(t, errors.Contains(err, tc.err))
 			assert.Equal(t, tc.resp, inv, tc.desc)
 			repoCall.Unset()
 			repoCall1.Unset()
+			repoCall2.Unset()
 		})
 	}
 }

pkg/sdk/invitations.go

@@ -43,15 +43,15 @@ func (sdk mgSDK) SendInvitation(invitation Invitation, token string) (err error)
 		return errors.NewSDKError(err)
 	}
 
-	url := sdk.domainsURL + "/" + invitationsEndpoint
+	url := sdk.domainsURL + "/" + invitation.DomainID + "/" + invitationsEndpoint
 
 	_, _, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusCreated)
 
 	return sdkerr
 }
 
 func (sdk mgSDK) Invitation(userID, domainID, token string) (invitation Invitation, err error) {
-	url := sdk.domainsURL + "/" + invitationsEndpoint + "/" + userID + "/" + domainID
+	url := sdk.domainsURL + "/" + domainID + "/" + invitationsEndpoint + "/" + userID
 
 	_, body, sdkerr := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK)
 	if sdkerr != nil {
@@ -121,7 +121,7 @@ func (sdk mgSDK) RejectInvitation(domainID, token string) (err error) {
 }
 
 func (sdk mgSDK) DeleteInvitation(userID, domainID, token string) (err error) {
-	url := sdk.domainsURL + "/" + invitationsEndpoint + "/" + userID + "/" + domainID
+	url := sdk.domainsURL + "/" + domainID + "/" + invitationsEndpoint + "/" + userID
 
 	_, _, sdkerr := sdk.processRequest(http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
 

pkg/sdk/invitations_test.go

@@ -118,7 +118,11 @@ func TestSendInvitation(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			if tc.token == valid {
-				tc.session = smqauthn.Session{UserID: tc.sendInvitationReq.UserID, DomainID: tc.sendInvitationReq.DomainID}
+				tc.session = smqauthn.Session{
+					UserID:       tc.sendInvitationReq.UserID,
+					DomainID:     tc.sendInvitationReq.DomainID,
+					DomainUserID: tc.sendInvitationReq.DomainID + "_" + tc.sendInvitationReq.UserID,
+				}
 			}
 			authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
 			svcCall := svc.On("SendInvitation", mock.Anything, tc.session, tc.svcReq).Return(tc.svcErr)
@@ -186,14 +190,14 @@ func TestViewInvitation(t *testing.T) {
 			err:      errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
 		},
 		{
-			desc:     "view invitation with empty userID",
+			desc:     "view invitation with empty domainID",
 			token:    validToken,
-			userID:   "",
-			domainID: invitation.DomainID,
+			userID:   invitation.UserID,
+			domainID: "",
 			svcRes:   domains.Invitation{},
 			svcErr:   nil,
 			response: sdk.Invitation{},
-			err:      errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingID), http.StatusBadRequest),
+			err:      errors.NewSDKErrorWithStatus(apiutil.ErrMissingDomainID, http.StatusBadRequest),
 		},
 		{
 			desc:     "view invitation with invalid domainID",
@@ -209,7 +213,7 @@ func TestViewInvitation(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			if tc.token == valid {
-				tc.session = smqauthn.Session{UserID: tc.userID, DomainID: tc.domainID}
+				tc.session = smqauthn.Session{UserID: tc.userID, DomainID: tc.domainID, DomainUserID: tc.domainID + "_" + tc.userID}
 			}
 			authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
 			svcCall := svc.On("ViewInvitation", mock.Anything, tc.session, tc.userID, tc.domainID).Return(tc.svcRes, tc.svcErr)
@@ -504,12 +508,12 @@ func TestDeleteInvitation(t *testing.T) {
 			err:      errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
 		},
 		{
-			desc:     "delete invitation with empty userID",
+			desc:     "delete invitation with empty domainID",
 			token:    validToken,
-			userID:   "",
-			domainID: invitation.DomainID,
+			userID:   invitation.UserID,
+			domainID: "",
 			svcErr:   nil,
-			err:      errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingID), http.StatusBadRequest),
+			err:      errors.NewSDKErrorWithStatus(apiutil.ErrMissingDomainID, http.StatusBadRequest),
 		},
 		{
 			desc:     "delete invitation with invalid domainID",
@@ -523,7 +527,7 @@ func TestDeleteInvitation(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			if tc.token == valid {
-				tc.session = smqauthn.Session{UserID: tc.userID, DomainID: tc.domainID}
+				tc.session = smqauthn.Session{UserID: tc.userID, DomainID: tc.domainID, DomainUserID: tc.domainID + "_" + tc.userID}
 			}
 			authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
 			svcCall := svc.On("DeleteInvitation", mock.Anything, tc.session, tc.userID, tc.domainID).Return(tc.svcErr)