NOISSUE - Fix typos (#2927)

Signed-off-by: fbugarski <filipbugarski@gmail.com>

auth/api/grpc/auth/endpoint_test.go

@@ -32,7 +32,7 @@ const (
 	usersType       = "users"
 	description     = "Description"
 	groupName       = "smqx"
-	adminpermission = "admin"
+	adminPermission = "admin"
 
 	authoritiesObj  = "authorities"
 	memberRelation  = "member"
@@ -134,7 +134,7 @@ func TestAuthorize(t *testing.T) {
 				Object:      authoritiesObj,
 				ObjectType:  usersType,
 				Relation:    memberRelation,
-				Permission:  adminpermission,
+				Permission:  adminPermission,
 			},
 			authResponse: &grpcAuthV1.AuthZRes{Authorized: true},
 			err:          nil,
@@ -148,7 +148,7 @@ func TestAuthorize(t *testing.T) {
 				Object:      authoritiesObj,
 				ObjectType:  usersType,
 				Relation:    memberRelation,
-				Permission:  adminpermission,
+				Permission:  adminPermission,
 			},
 			authResponse: &grpcAuthV1.AuthZRes{Authorized: false},
 			err:          svcerr.ErrAuthorization,
@@ -162,7 +162,7 @@ func TestAuthorize(t *testing.T) {
 				Object:      authoritiesObj,
 				ObjectType:  usersType,
 				Relation:    memberRelation,
-				Permission:  adminpermission,
+				Permission:  adminPermission,
 			},
 			authResponse: &grpcAuthV1.AuthZRes{Authorized: false},
 			err:          apiutil.ErrMissingPolicySub,
@@ -176,7 +176,7 @@ func TestAuthorize(t *testing.T) {
 				Object:      authoritiesObj,
 				ObjectType:  usersType,
 				Relation:    memberRelation,
-				Permission:  adminpermission,
+				Permission:  adminPermission,
 			},
 			authResponse: &grpcAuthV1.AuthZRes{Authorized: false},
 			err:          apiutil.ErrMissingPolicySub,
@@ -190,7 +190,7 @@ func TestAuthorize(t *testing.T) {
 				Object:      "",
 				ObjectType:  usersType,
 				Relation:    memberRelation,
-				Permission:  adminpermission,
+				Permission:  adminPermission,
 			},
 			authResponse: &grpcAuthV1.AuthZRes{Authorized: false},
 			err:          apiutil.ErrMissingPolicyObj,
@@ -204,7 +204,7 @@ func TestAuthorize(t *testing.T) {
 				Object:      authoritiesObj,
 				ObjectType:  "",
 				Relation:    memberRelation,
-				Permission:  adminpermission,
+				Permission:  adminPermission,
 			},
 			authResponse: &grpcAuthV1.AuthZRes{Authorized: false},
 			err:          apiutil.ErrMissingPolicyObj,
@@ -226,13 +226,13 @@ func TestAuthorize(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			svccall := svc.On("Authorize", mock.Anything, mock.Anything).Return(tc.err)
+			svcCall := svc.On("Authorize", mock.Anything, mock.Anything).Return(tc.err)
 			ar, err := grpcClient.Authorize(context.Background(), tc.authRequest)
 			if ar != nil {
 				assert.Equal(t, tc.authResponse, ar, fmt.Sprintf("%s: expected %v got %v", tc.desc, tc.authResponse, ar))
 			}
 			assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
-			svccall.Unset()
+			svcCall.Unset()
 		})
 	}
 }
@@ -354,7 +354,7 @@ func TestAuthorizePAT(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			svccall := svc.On("AuthorizePAT",
+			svcCall := svc.On("AuthorizePAT",
 				mock.Anything,
 				tc.authRequest.UserId,
 				tc.authRequest.PatId,
@@ -368,7 +368,7 @@ func TestAuthorizePAT(t *testing.T) {
 				assert.Equal(t, tc.authResponse, ar, fmt.Sprintf("%s: expected %v got %v", tc.desc, tc.authResponse, ar))
 			}
 			assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
-			svccall.Unset()
+			svcCall.Unset()
 		})
 	}
 }

auth/api/grpc/token/endpoint_test.go

@@ -32,7 +32,7 @@ const (
 	usersType       = "users"
 	description     = "Description"
 	groupName       = "smqx"
-	adminpermission = "admin"
+	adminPermission = "admin"
 
 	authoritiesObj  = "authorities"
 	memberRelation  = "member"

auth/api/http/keys/endpoint_test.go

@@ -201,12 +201,12 @@ func TestIssue(t *testing.T) {
 			token:       tc.token,
 			body:        strings.NewReader(tc.req),
 		}
-		repocall := krepo.On("Save", mock.Anything, mock.Anything).Return("", nil)
+		repoCall := krepo.On("Save", mock.Anything, mock.Anything).Return("", nil)
 		policyCall := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
 		res, err := req.make()
 		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
 		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		repocall.Unset()
+		repoCall.Unset()
 		policyCall.Unset()
 	}
 }
@@ -218,10 +218,10 @@ func TestRetrieve(t *testing.T) {
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
 	key := auth.Key{Type: auth.APIKey, IssuedAt: time.Now(), Subject: id}
 
-	repocall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
 	k, err := svc.Issue(context.Background(), token.AccessToken, key)
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
-	repocall.Unset()
+	repoCall.Unset()
 	policyCall.Unset()
 
 	ts := newServer(svc)
@@ -280,11 +280,11 @@ func TestRetrieve(t *testing.T) {
 			token:  tc.token,
 		}
 		policyCall := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
-		repocall := krepo.On("Retrieve", mock.Anything, mock.Anything, mock.Anything).Return(tc.key, tc.err)
+		repoCall := krepo.On("Retrieve", mock.Anything, mock.Anything, mock.Anything).Return(tc.key, tc.err)
 		res, err := req.make()
 		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
 		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		repocall.Unset()
+		repoCall.Unset()
 		policyCall.Unset()
 	}
 }
@@ -296,10 +296,10 @@ func TestRevoke(t *testing.T) {
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
 	key := auth.Key{Type: auth.APIKey, IssuedAt: time.Now(), Subject: id}
 
-	repocall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
 	k, err := svc.Issue(context.Background(), token.AccessToken, key)
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
-	repocall.Unset()
+	repoCall.Unset()
 	policyCall.Unset()
 
 	ts := newServer(svc)
@@ -345,10 +345,10 @@ func TestRevoke(t *testing.T) {
 			url:    fmt.Sprintf("%s/keys/%s", ts.URL, tc.id),
 			token:  tc.token,
 		}
-		repocall := krepo.On("Remove", mock.Anything, mock.Anything, mock.Anything).Return(nil)
+		repoCall := krepo.On("Remove", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 		res, err := req.make()
 		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
 		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		repocall.Unset()
+		repoCall.Unset()
 	}
 }

auth/api/http/pats/requests.go

@@ -199,12 +199,12 @@ type addScopeReq struct {
 	Scopes []auth.Scope `json:"scopes,omitempty"`
 }
 
-func (aser *addScopeReq) UnmarshalJSON(data []byte) error {
+func (req *addScopeReq) UnmarshalJSON(data []byte) error {
 	type Alias addScopeReq
 	aux := &struct {
 		*Alias
 	}{
-		Alias: (*Alias)(aser),
+		Alias: (*Alias)(req),
 	}
 
 	if err := json.Unmarshal(data, aux); err != nil {

auth/service_test.go

@@ -321,12 +321,12 @@ func TestIssue(t *testing.T) {
 
 func TestRevoke(t *testing.T) {
 	svc, _ := newService()
-	repocall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, errIssueUser)
+	repoCall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, errIssueUser)
 	policyCall := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
 	secret, err := svc.Issue(context.Background(), "", auth.Key{Type: auth.AccessKey, Role: auth.UserRole, IssuedAt: time.Now(), Subject: userID})
-	repocall.Unset()
+	repoCall.Unset()
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
-	repocall1 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall1 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
 	key := auth.Key{
 		Type:     auth.APIKey,
 		Role:     auth.UserRole,
@@ -335,7 +335,7 @@ func TestRevoke(t *testing.T) {
 	}
 	_, err = svc.Issue(context.Background(), secret.AccessToken, key)
 	assert.Nil(t, err, fmt.Sprintf("Issuing user's key expected to succeed: %s", err))
-	repocall1.Unset()
+	repoCall1.Unset()
 	policyCall.Unset()
 
 	cases := []struct {
@@ -368,20 +368,20 @@ func TestRevoke(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		repocall := krepo.On("Remove", mock.Anything, mock.Anything, mock.Anything).Return(tc.err)
+		repoCall := krepo.On("Remove", mock.Anything, mock.Anything, mock.Anything).Return(tc.err)
 		err := svc.Revoke(context.Background(), tc.token, tc.id)
 		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s expected %s got %s\n", tc.desc, tc.err, err))
-		repocall.Unset()
+		repoCall.Unset()
 	}
 }
 
 func TestRetrieve(t *testing.T) {
 	svc, _ := newService()
-	repocall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
-	repocall1 := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
+	repoCall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall1 := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
 	secret, err := svc.Issue(context.Background(), "", auth.Key{Type: auth.AccessKey, Subject: userID, Role: auth.UserRole, IssuedAt: time.Now()})
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
-	repocall.Unset()
+	repoCall.Unset()
 	key := auth.Key{
 		ID:       "id",
 		Type:     auth.APIKey,
@@ -390,21 +390,21 @@ func TestRetrieve(t *testing.T) {
 		IssuedAt: time.Now(),
 	}
 
-	repocall3 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall3 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
 	userToken, err := svc.Issue(context.Background(), "", auth.Key{Type: auth.AccessKey, Subject: userID, Role: auth.UserRole, IssuedAt: time.Now()})
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
-	repocall3.Unset()
+	repoCall3.Unset()
 
-	repocall4 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall4 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
 	apiToken, err := svc.Issue(context.Background(), secret.AccessToken, key)
 	assert.Nil(t, err, fmt.Sprintf("Issuing login's key expected to succeed: %s", err))
-	repocall4.Unset()
+	repoCall4.Unset()
 
-	repocall5 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall5 := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
 	resetToken, err := svc.Issue(context.Background(), "", auth.Key{Type: auth.RecoveryKey, Subject: userID, Role: auth.UserRole, IssuedAt: time.Now()})
 	assert.Nil(t, err, fmt.Sprintf("Issuing reset key expected to succeed: %s", err))
-	repocall5.Unset()
-	repocall1.Unset()
+	repoCall5.Unset()
+	repoCall1.Unset()
 
 	cases := []struct {
 		desc  string
@@ -441,18 +441,18 @@ func TestRetrieve(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		repocall := krepo.On("Retrieve", mock.Anything, mock.Anything, mock.Anything).Return(auth.Key{}, tc.err)
+		repoCall := krepo.On("Retrieve", mock.Anything, mock.Anything, mock.Anything).Return(auth.Key{}, tc.err)
 		_, err := svc.RetrieveKey(context.Background(), tc.token, tc.id)
 		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s expected %s got %s\n", tc.desc, tc.err, err))
-		repocall.Unset()
+		repoCall.Unset()
 	}
 }
 
 func TestIdentify(t *testing.T) {
 	svc, _ := newService()
 
-	repocall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
-	repocall1 := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
+	repoCall := krepo.On("Save", mock.Anything, mock.Anything).Return(mock.Anything, nil)
+	repoCall1 := pEvaluator.On("CheckPolicy", mock.Anything, mock.Anything).Return(nil)
 	loginSecret, err := svc.Issue(context.Background(), "", auth.Key{Type: auth.AccessKey, Subject: userID, Role: auth.UserRole, IssuedAt: time.Now()})
 	assert.Nil(t, err, fmt.Sprintf("Issuing login key expected to succeed: %s", err))
 
@@ -466,8 +466,8 @@ func TestIdentify(t *testing.T) {
 	exp1 := time.Now().UTC().Add(-1 * time.Minute).Round(time.Second)
 	expSecret, err := svc.Issue(context.Background(), loginSecret.AccessToken, auth.Key{Type: auth.APIKey, Role: auth.UserRole, IssuedAt: exp0, ExpiresAt: exp1})
 	assert.Nil(t, err, fmt.Sprintf("Issuing expired login key expected to succeed: %s", err))
-	repocall.Unset()
-	repocall1.Unset()
+	repoCall.Unset()
+	repoCall1.Unset()
 
 	te := jwt.New([]byte(secret))
 	key := auth.Key{
@@ -536,13 +536,13 @@ func TestIdentify(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		repocall := krepo.On("Retrieve", mock.Anything, mock.Anything, mock.Anything).Return(auth.Key{}, tc.err)
-		repocall1 := krepo.On("Remove", mock.Anything, mock.Anything, mock.Anything).Return(tc.err)
+		repoCall := krepo.On("Retrieve", mock.Anything, mock.Anything, mock.Anything).Return(auth.Key{}, tc.err)
+		repoCall1 := krepo.On("Remove", mock.Anything, mock.Anything, mock.Anything).Return(tc.err)
 		idt, err := svc.Identify(context.Background(), tc.key)
 		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s expected %s got %s\n", tc.desc, tc.err, err))
 		assert.Equal(t, tc.subject, idt.Subject, fmt.Sprintf("%s expected %s got %s\n", tc.desc, tc.subject, idt))
-		repocall.Unset()
-		repocall1.Unset()
+		repoCall.Unset()
+		repoCall1.Unset()
 	}
 }
 

channels/service.go

@@ -110,11 +110,11 @@ func (svc service) CreateChannels(ctx context.Context, session authn.Session, ch
 			},
 		)
 	}
-	nrps, err := svc.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, chIDs, optionalPolicies, newBuiltInRoleMembers)
+	rp, err := svc.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, chIDs, optionalPolicies, newBuiltInRoleMembers)
 	if err != nil {
 		return []Channel{}, []roles.RoleProvision{}, errors.Wrap(svcerr.ErrAddPolicies, err)
 	}
-	return savedChs, nrps, nil
+	return savedChs, rp, nil
 }
 
 func (svc service) UpdateChannel(ctx context.Context, session authn.Session, ch Channel) (Channel, error) {

cli/users_test.go

@@ -50,7 +50,7 @@ func TestCreateUsersCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		logType       outputLog
@@ -90,7 +90,7 @@ func TestCreateUsersCmd(t *testing.T) {
 				user.Credentials.Username,
 				validToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrCreateEntity, http.StatusUnprocessableEntity),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrCreateEntity, http.StatusUnprocessableEntity),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrCreateEntity, http.StatusUnprocessableEntity).Error()),
 			logType:       errLog,
 		},
@@ -103,7 +103,7 @@ func TestCreateUsersCmd(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("CreateUser", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("CreateUser", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkErr)
 			if len(tc.args) == 4 {
 				sdkUser := mgsdk.User{
 					FirstName: tc.args[0],
@@ -113,7 +113,7 @@ func TestCreateUsersCmd(t *testing.T) {
 						Secret: tc.args[3],
 					},
 				}
-				sdkCall = sdkMock.On("CreateUser", mock.Anything, mock.Anything, sdkUser).Return(tc.user, tc.sdkerr)
+				sdkCall = sdkMock.On("CreateUser", mock.Anything, mock.Anything, sdkUser).Return(tc.user, tc.sdkErr)
 			}
 			out := executeCommand(t, rootCmd, append([]string{createCmd}, tc.args...)...)
 
@@ -147,7 +147,7 @@ func TestGetUsersCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		page          mgsdk.UsersPage
@@ -159,7 +159,7 @@ func TestGetUsersCmd(t *testing.T) {
 				all,
 				validToken,
 			},
-			sdkerr: nil,
+			sdkErr: nil,
 			page: mgsdk.UsersPage{
 				Users: []mgsdk.User{user},
 			},
@@ -171,7 +171,7 @@ func TestGetUsersCmd(t *testing.T) {
 				userID,
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			user:    user,
 			logType: entityLog,
 		},
@@ -181,7 +181,7 @@ func TestGetUsersCmd(t *testing.T) {
 				invalidID,
 				validToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrViewEntity, http.StatusBadRequest),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrViewEntity, http.StatusBadRequest),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrViewEntity, http.StatusBadRequest).Error()),
 			user:          mgsdk.User{},
 			logType:       errLog,
@@ -194,7 +194,7 @@ func TestGetUsersCmd(t *testing.T) {
 				"--offset=2",
 				"--limit=5",
 			},
-			sdkerr: nil,
+			sdkErr: nil,
 			page: mgsdk.UsersPage{
 				Users: []mgsdk.User{user},
 			},
@@ -206,7 +206,7 @@ func TestGetUsersCmd(t *testing.T) {
 				all,
 				invalidToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden).Error()),
 			page:          mgsdk.UsersPage{},
 			logType:       errLog,
@@ -231,7 +231,7 @@ func TestGetUsersCmd(t *testing.T) {
 				userID,
 				validToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrViewEntity, http.StatusInternalServerError),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrViewEntity, http.StatusInternalServerError),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrViewEntity, http.StatusInternalServerError).Error()),
 			user:          mgsdk.User{},
 			logType:       errLog,
@@ -240,8 +240,8 @@ func TestGetUsersCmd(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("Users", mock.Anything, mock.Anything, mock.Anything).Return(tc.page, tc.sdkerr)
-			sdkCall1 := sdkMock.On("User", mock.Anything, tc.args[0], tc.args[1]).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("Users", mock.Anything, mock.Anything, mock.Anything).Return(tc.page, tc.sdkErr)
+			sdkCall1 := sdkMock.On("User", mock.Anything, tc.args[0], tc.args[1]).Return(tc.user, tc.sdkErr)
 
 			out = executeCommand(t, rootCmd, append([]string{getCmd}, tc.args...)...)
 
@@ -298,7 +298,7 @@ func TestIssueTokenCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		token         mgsdk.Token
 		logType       outputLog
@@ -309,7 +309,7 @@ func TestIssueTokenCmd(t *testing.T) {
 				user.Email,
 				user.Credentials.Secret,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: entityLog,
 			token:   token,
 		},
@@ -319,7 +319,7 @@ func TestIssueTokenCmd(t *testing.T) {
 				user.Email,
 				invalidPassword,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden).Error()),
 			logType:       errLog,
 			token:         mgsdk.Token{},
@@ -341,7 +341,7 @@ func TestIssueTokenCmd(t *testing.T) {
 				Username: tc.args[0],
 				Password: tc.args[1],
 			}
-			sdkCall := sdkMock.On("CreateToken", mock.Anything, lg).Return(tc.token, tc.sdkerr)
+			sdkCall := sdkMock.On("CreateToken", mock.Anything, lg).Return(tc.token, tc.sdkErr)
 
 			out := executeCommand(t, rootCmd, append([]string{tokCmd}, tc.args...)...)
 
@@ -377,7 +377,7 @@ func TestRefreshIssueTokenCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		token         mgsdk.Token
 		logType       outputLog
@@ -387,7 +387,7 @@ func TestRefreshIssueTokenCmd(t *testing.T) {
 			args: []string{
 				"token",
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: entityLog,
 			token:   token,
 		},
@@ -404,7 +404,7 @@ func TestRefreshIssueTokenCmd(t *testing.T) {
 			args: []string{
 				"invalidToken",
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden).Error()),
 			logType:       errLog,
 			token:         mgsdk.Token{},
@@ -413,7 +413,7 @@ func TestRefreshIssueTokenCmd(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("RefreshToken", mock.Anything, mock.Anything).Return(tc.token, tc.sdkerr)
+			sdkCall := sdkMock.On("RefreshToken", mock.Anything, mock.Anything).Return(tc.token, tc.sdkErr)
 
 			out := executeCommand(t, rootCmd, append([]string{refTokCmd}, tc.args...)...)
 
@@ -454,7 +454,7 @@ func TestUpdateUserCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		logType       outputLog
@@ -467,7 +467,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				newTagsJSON,
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: entityLog,
 			user:    user,
 		},
@@ -479,7 +479,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				"[\"tag1\", \"tag2\"",
 				validToken,
 			},
-			sdkerr:        errors.NewSDKError(errors.New("unexpected end of JSON input")),
+			sdkErr:        errors.NewSDKError(errors.New("unexpected end of JSON input")),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
 			logType:       errLog,
 		},
@@ -492,7 +492,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 		{
@@ -515,7 +515,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 		{
@@ -536,7 +536,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 		{
@@ -546,7 +546,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				"{\"name\":\"new name\", \"metadata\":{\"key\": \"value\"}",
 				validToken,
 			},
-			sdkerr:        errors.NewSDKError(errors.New("unexpected end of JSON input")),
+			sdkErr:        errors.NewSDKError(errors.New("unexpected end of JSON input")),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
 			logType:       errLog,
 		},
@@ -570,7 +570,7 @@ func TestUpdateUserCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 		{
@@ -588,34 +588,34 @@ func TestUpdateUserCmd(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("UpdateUser", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkerr)
-			sdkCall1 := sdkMock.On("UpdateUserTags", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkerr)
-			sdkCall2 := sdkMock.On("UpdateUserIdentity", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkerr)
-			sdkCall3 := sdkMock.On("UpdateUserRole", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("UpdateUser", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkErr)
+			sdkCall1 := sdkMock.On("UpdateUserTags", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkErr)
+			sdkCall2 := sdkMock.On("UpdateUserIdentity", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkErr)
+			sdkCall3 := sdkMock.On("UpdateUserRole", mock.Anything, mock.Anything, mock.Anything).Return(tc.user, tc.sdkErr)
 			switch {
 			case tc.args[0] == tagUpdateType:
 				var u mgsdk.User
 				u.Tags = []string{"tag1", "tag2"}
 				u.ID = tc.args[1]
 
-				sdkCall1 = sdkMock.On("UpdateUserTags", mock.Anything, u, tc.args[3]).Return(tc.user, tc.sdkerr)
+				sdkCall1 = sdkMock.On("UpdateUserTags", mock.Anything, u, tc.args[3]).Return(tc.user, tc.sdkErr)
 			case tc.args[0] == emailUpdateType:
 				var u mgsdk.User
 				u.Email = tc.args[2]
 				u.ID = tc.args[1]
 
-				sdkCall2 = sdkMock.On("UpdateUserEmail", mock.Anything, u, tc.args[3]).Return(tc.user, tc.sdkerr)
+				sdkCall2 = sdkMock.On("UpdateUserEmail", mock.Anything, u, tc.args[3]).Return(tc.user, tc.sdkErr)
 			case tc.args[0] == roleUpdateType && len(tc.args) == 4:
 				sdkCall3 = sdkMock.On("UpdateUserRole", mock.Anything, mgsdk.User{
 					Role: tc.args[2],
-				}, tc.args[3]).Return(tc.user, tc.sdkerr)
+				}, tc.args[3]).Return(tc.user, tc.sdkErr)
 			case tc.args[0] == userID:
 				sdkCall = sdkMock.On("UpdateUser", mock.Anything, mgsdk.User{
 					FirstName: "new name",
 					Metadata: mgsdk.Metadata{
 						"key": "value",
 					},
-				}, tc.args[2]).Return(tc.user, tc.sdkerr)
+				}, tc.args[2]).Return(tc.user, tc.sdkErr)
 			}
 			out := executeCommand(t, rootCmd, append([]string{updCmd}, tc.args...)...)
 
@@ -649,7 +649,7 @@ func TestGetUserProfileCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		logType       outputLog
@@ -659,7 +659,7 @@ func TestGetUserProfileCmd(t *testing.T) {
 			args: []string{
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: entityLog,
 		},
 		{
@@ -676,14 +676,14 @@ func TestGetUserProfileCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("UserProfile", mock.Anything, tc.args[0]).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("UserProfile", mock.Anything, tc.args[0]).Return(tc.user, tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{profCmd}, tc.args...)...)
 
 			switch tc.logType {
@@ -711,7 +711,7 @@ func TestResetPasswordRequestCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		logType       outputLog
 	}{
@@ -720,7 +720,7 @@ func TestResetPasswordRequestCmd(t *testing.T) {
 			args: []string{
 				exampleEmail,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: okLog,
 		},
 		{
@@ -736,7 +736,7 @@ func TestResetPasswordRequestCmd(t *testing.T) {
 			args: []string{
 				exampleEmail,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusUnprocessableEntity),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusUnprocessableEntity),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusUnprocessableEntity).Error()),
 			logType:       errLog,
 		},
@@ -744,7 +744,7 @@ func TestResetPasswordRequestCmd(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("ResetPasswordRequest", mock.Anything, tc.args[0]).Return(tc.sdkerr)
+			sdkCall := sdkMock.On("ResetPasswordRequest", mock.Anything, tc.args[0]).Return(tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{resPassReqCmd}, tc.args...)...)
 
 			switch tc.logType {
@@ -770,7 +770,7 @@ func TestResetPasswordCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		logType       outputLog
 	}{
@@ -781,7 +781,7 @@ func TestResetPasswordCmd(t *testing.T) {
 				newPassword,
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: okLog,
 		},
 		{
@@ -802,14 +802,14 @@ func TestResetPasswordCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("ResetPassword", mock.Anything, tc.args[0], tc.args[1], tc.args[2]).Return(tc.sdkerr)
+			sdkCall := sdkMock.On("ResetPassword", mock.Anything, tc.args[0], tc.args[1], tc.args[2]).Return(tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{resPassCmd}, tc.args...)...)
 
 			switch tc.logType {
@@ -838,7 +838,7 @@ func TestUpdatePasswordCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		logType       outputLog
@@ -850,7 +850,7 @@ func TestUpdatePasswordCmd(t *testing.T) {
 				newPassword,
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: entityLog,
 			user:    user,
 		},
@@ -862,7 +862,7 @@ func TestUpdatePasswordCmd(t *testing.T) {
 				validToken,
 				extraArg,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: usageLog,
 			user:    user,
 		},
@@ -874,14 +874,14 @@ func TestUpdatePasswordCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("UpdatePassword", mock.Anything, tc.args[0], tc.args[1], tc.args[2]).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("UpdatePassword", mock.Anything, tc.args[0], tc.args[1], tc.args[2]).Return(tc.user, tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{passCmd}, tc.args...)...)
 
 			switch tc.logType {
@@ -910,7 +910,7 @@ func TestEnableUserCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		logType       outputLog
@@ -921,7 +921,7 @@ func TestEnableUserCmd(t *testing.T) {
 				user.ID,
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			user:    user,
 			logType: entityLog,
 		},
@@ -941,14 +941,14 @@ func TestEnableUserCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("EnableUser", mock.Anything, tc.args[0], tc.args[1]).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("EnableUser", mock.Anything, tc.args[0], tc.args[1]).Return(tc.user, tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{enableCmd}, tc.args...)...)
 
 			switch tc.logType {
@@ -978,7 +978,7 @@ func TestDisableUserCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		user          mgsdk.User
 		logType       outputLog
@@ -989,7 +989,7 @@ func TestDisableUserCmd(t *testing.T) {
 				user.ID,
 				validToken,
 			},
-			sdkerr:  nil,
+			sdkErr:  nil,
 			logType: entityLog,
 			user:    user,
 		},
@@ -1009,14 +1009,14 @@ func TestDisableUserCmd(t *testing.T) {
 				invalidToken,
 			},
 			logType:       errLog,
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("DisableUser", mock.Anything, tc.args[0], tc.args[1]).Return(tc.user, tc.sdkerr)
+			sdkCall := sdkMock.On("DisableUser", mock.Anything, tc.args[0], tc.args[1]).Return(tc.user, tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{disableCmd}, tc.args...)...)
 
 			switch tc.logType {
@@ -1046,7 +1046,7 @@ func TestDeleteUserCmd(t *testing.T) {
 	cases := []struct {
 		desc          string
 		args          []string
-		sdkerr        errors.SDKError
+		sdkErr        errors.SDKError
 		errLogMessage string
 		logType       outputLog
 	}{
@@ -1073,7 +1073,7 @@ func TestDeleteUserCmd(t *testing.T) {
 				user.ID,
 				invalidToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden).Error()),
 			logType:       errLog,
 		},
@@ -1083,7 +1083,7 @@ func TestDeleteUserCmd(t *testing.T) {
 				invalidID,
 				validToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden).Error()),
 			logType:       errLog,
 		},
@@ -1093,7 +1093,7 @@ func TestDeleteUserCmd(t *testing.T) {
 				user.ID,
 				validToken,
 			},
-			sdkerr:        errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusUnprocessableEntity),
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusUnprocessableEntity),
 			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusUnprocessableEntity).Error()),
 			logType:       errLog,
 		},
@@ -1109,7 +1109,7 @@ func TestDeleteUserCmd(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			sdkCall := sdkMock.On("DeleteUser", mock.Anything, mock.Anything, mock.Anything).Return(tc.sdkerr)
+			sdkCall := sdkMock.On("DeleteUser", mock.Anything, mock.Anything, mock.Anything).Return(tc.sdkErr)
 			out := executeCommand(t, rootCmd, append([]string{delCmd}, tc.args...)...)
 
 			switch tc.logType {

clients/service.go

@@ -113,12 +113,12 @@ func (svc service) CreateClients(ctx context.Context, session authn.Session, cls
 		)
 	}
 
-	nrps, err := svc.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, newClientIDs, optionalPolicies, newBuiltInRoleMembers)
+	rp, err := svc.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, newClientIDs, optionalPolicies, newBuiltInRoleMembers)
 	if err != nil {
 		return []Client{}, []roles.RoleProvision{}, errors.Wrap(svcerr.ErrAddPolicies, err)
 	}
 
-	return newClients, nrps, nil
+	return newClients, rp, nil
 }
 
 func (svc service) View(ctx context.Context, session authn.Session, id string, withRoles bool) (Client, error) {

domains/api/grpc/endpoint_test.go

@@ -33,7 +33,7 @@ const (
 	usersType       = "users"
 	description     = "Description"
 	groupName       = "smqx"
-	adminpermission = "admin"
+	adminPermission = "admin"
 	authoritiesObj  = "authorities"
 	memberRelation  = "member"
 	loginDuration   = 30 * time.Minute

groups/service.go

@@ -97,12 +97,12 @@ func (svc service) CreateGroup(ctx context.Context, session smqauthn.Session, g
 	newBuiltInRoleMembers := map[roles.BuiltInRoleName][]roles.Member{
 		BuiltInRoleAdmin: {roles.Member(session.UserID)},
 	}
-	nrps, err := svc.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, []string{saved.ID}, oprs, newBuiltInRoleMembers)
+	rp, err := svc.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, []string{saved.ID}, oprs, newBuiltInRoleMembers)
 	if err != nil {
 		return Group{}, []roles.RoleProvision{}, errors.Wrap(svcerr.ErrAddPolicies, err)
 	}
 
-	return saved, nrps, nil
+	return saved, rp, nil
 }
 
 func (svc service) ViewGroup(ctx context.Context, session smqauthn.Session, id string, withRoles bool) (Group, error) {

pkg/roles/provisionmanage.go

@@ -147,7 +147,7 @@ func (r ProvisionManageService) RemoveEntitiesRoles(ctx context.Context, domainI
 
 func (r ProvisionManageService) AddNewEntitiesRoles(ctx context.Context, domainID, userID string, entityIDs []string, optionalEntityPolicies []policies.Policy, newBuiltInRoleMembers map[BuiltInRoleName][]Member) (retRolesProvision []RoleProvision, retErr error) {
 	var newRolesProvision []RoleProvision
-	prs := []policies.Policy{}
+	p := []policies.Policy{}
 
 	for _, entityID := range entityIDs {
 		for defaultRole, defaultRoleMembers := range newBuiltInRoleMembers {
@@ -182,7 +182,7 @@ func (r ProvisionManageService) AddNewEntitiesRoles(ctx context.Context, domainI
 			})
 
 			for _, cap := range caps {
-				prs = append(prs, policies.Policy{
+				p = append(p, policies.Policy{
 					SubjectType:     policies.RoleType,
 					SubjectRelation: policies.MemberRelation,
 					Subject:         id,
@@ -193,7 +193,7 @@ func (r ProvisionManageService) AddNewEntitiesRoles(ctx context.Context, domainI
 			}
 
 			for _, member := range members {
-				prs = append(prs, policies.Policy{
+				p = append(p, policies.Policy{
 					SubjectType: policies.UserType,
 					Subject:     policies.EncodeDomainUserID(domainID, member),
 					Relation:    policies.MemberRelation,
@@ -203,27 +203,27 @@ func (r ProvisionManageService) AddNewEntitiesRoles(ctx context.Context, domainI
 			}
 		}
 	}
-	prs = append(prs, optionalEntityPolicies...)
+	p = append(p, optionalEntityPolicies...)
 
-	if len(prs) > 0 {
-		if err := r.policy.AddPolicies(ctx, prs); err != nil {
+	if len(p) > 0 {
+		if err := r.policy.AddPolicies(ctx, p); err != nil {
 			return []RoleProvision{}, errors.Wrap(svcerr.ErrCreateEntity, err)
 		}
 		defer func() {
 			if retErr != nil {
-				if errRollBack := r.policy.DeletePolicies(ctx, prs); errRollBack != nil {
+				if errRollBack := r.policy.DeletePolicies(ctx, p); errRollBack != nil {
 					retErr = errors.Wrap(retErr, errors.Wrap(errRollbackRoles, errRollBack))
 				}
 			}
 		}()
 	}
 
-	nprs, err := r.repo.AddRoles(ctx, newRolesProvision)
+	rp, err := r.repo.AddRoles(ctx, newRolesProvision)
 	if err != nil {
 		return []RoleProvision{}, errors.Wrap(svcerr.ErrCreateEntity, err)
 	}
 
-	return nprs, nil
+	return rp, nil
 }
 
 func (r ProvisionManageService) AddRole(ctx context.Context, session authn.Session, entityID string, roleName string, optionalActions []string, optionalMembers []string) (retRoleProvision RoleProvision, retErr error) {
@@ -288,16 +288,16 @@ func (r ProvisionManageService) AddRole(ctx context.Context, session authn.Sessi
 		}()
 	}
 
-	nrps, err := r.repo.AddRoles(ctx, newRoleProvisions)
+	rp, err := r.repo.AddRoles(ctx, newRoleProvisions)
 	if err != nil {
 		return RoleProvision{}, errors.Wrap(svcerr.ErrCreateEntity, err)
 	}
 
-	if len(nrps) == 0 {
+	if len(rp) == 0 {
 		return RoleProvision{}, svcerr.ErrCreateEntity
 	}
 
-	return nrps[0], nil
+	return rp[0], nil
 }
 
 func (r ProvisionManageService) RemoveRole(ctx context.Context, session authn.Session, entityID, roleID string) error {

pkg/sdk/certs.go

@@ -43,9 +43,9 @@ func (sdk mgSDK) IssueCert(ctx context.Context, clientID, validity, domainID, to
 
 	url := fmt.Sprintf("%s/%s/%s", sdk.certsURL, domainID, certsEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, d, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Cert{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, d, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Cert{}, sdkErr
 	}
 
 	var c Cert

pkg/sdk/channels.go

@@ -44,9 +44,9 @@ func (sdk mgSDK) CreateChannel(ctx context.Context, c Channel, domainID, token s
 	}
 	url := fmt.Sprintf("%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Channel{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Channel{}, sdkErr
 	}
 
 	c = Channel{}
@@ -65,9 +65,9 @@ func (sdk mgSDK) CreateChannels(ctx context.Context, channels []Channel, domainI
 
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, "bulk")
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return []Channel{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return []Channel{}, sdkErr
 	}
 
 	res := createChannelsRes{}
@@ -85,9 +85,9 @@ func (sdk mgSDK) Channels(ctx context.Context, pm PageMetadata, domainID, token
 		return ChannelsPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return ChannelsPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return ChannelsPage{}, sdkErr
 	}
 
 	var cp ChannelsPage
@@ -128,9 +128,9 @@ func (sdk mgSDK) UpdateChannel(ctx context.Context, c Channel, domainID, token s
 		return Channel{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Channel{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Channel{}, sdkErr
 	}
 
 	c = Channel{}
@@ -152,9 +152,9 @@ func (sdk mgSDK) UpdateChannelTags(ctx context.Context, c Channel, domainID, tok
 		return Channel{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Channel{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Channel{}, sdkErr
 	}
 
 	c = Channel{}
@@ -173,9 +173,9 @@ func (sdk mgSDK) Connect(ctx context.Context, conn Connection, domainID, token s
 
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, connectEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) Disconnect(ctx context.Context, conn Connection, domainID, token string) errors.SDKError {
@@ -186,9 +186,9 @@ func (sdk mgSDK) Disconnect(ctx context.Context, conn Connection, domainID, toke
 
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, disconnectEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) ConnectClients(ctx context.Context, channelID string, clientIDs, connTypes []string, domainID, token string) errors.SDKError {
@@ -202,9 +202,9 @@ func (sdk mgSDK) ConnectClients(ctx context.Context, channelID string, clientIDs
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, channelID, connectEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) DisconnectClients(ctx context.Context, channelID string, clientIDs, connTypes []string, domainID, token string) errors.SDKError {
@@ -218,9 +218,9 @@ func (sdk mgSDK) DisconnectClients(ctx context.Context, channelID string, client
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, channelID, disconnectEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) EnableChannel(ctx context.Context, id, domainID, token string) (Channel, errors.SDKError) {
@@ -236,8 +236,8 @@ func (sdk mgSDK) DeleteChannel(ctx context.Context, id, domainID, token string)
 		return errors.NewSDKError(apiutil.ErrMissingID)
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, id)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
-	return sdkerr
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	return sdkErr
 }
 
 func (sdk mgSDK) changeChannelStatus(ctx context.Context, id, status, domainID, token string) (Channel, errors.SDKError) {
@@ -263,22 +263,22 @@ func (sdk mgSDK) SetChannelParent(ctx context.Context, id, domainID, groupID, to
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, id, parentEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) RemoveChannelParent(ctx context.Context, id, domainID, groupID, token string) errors.SDKError {
-	rcpg := parentGroupReq{ParentGroupID: groupID}
-	data, err := json.Marshal(rcpg)
+	pgr := parentGroupReq{ParentGroupID: groupID}
+	data, err := json.Marshal(pgr)
 	if err != nil {
 		return errors.NewSDKError(err)
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.channelsURL, domainID, channelsEndpoint, id, parentEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) ListChannelMembers(ctx context.Context, channelID, domainID string, pm PageMetadata, token string) (EntityMembersPage, errors.SDKError) {

pkg/sdk/clients.go

@@ -55,9 +55,9 @@ func (sdk mgSDK) CreateClient(ctx context.Context, client Client, domainID, toke
 
 	url := fmt.Sprintf("%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Client{}, sdkErr
 	}
 
 	client = Client{}
@@ -76,9 +76,9 @@ func (sdk mgSDK) CreateClients(ctx context.Context, clients []Client, domainID,
 
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint, "bulk")
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return []Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return []Client{}, sdkErr
 	}
 
 	var ctr createClientsRes
@@ -96,9 +96,9 @@ func (sdk mgSDK) Clients(ctx context.Context, pm PageMetadata, domainID, token s
 		return ClientsPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return ClientsPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return ClientsPage{}, sdkErr
 	}
 
 	var cp ClientsPage
@@ -115,9 +115,9 @@ func (sdk mgSDK) Client(ctx context.Context, id, domainID, token string) (Client
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint, id)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Client{}, sdkErr
 	}
 
 	var t Client
@@ -139,9 +139,9 @@ func (sdk mgSDK) UpdateClient(ctx context.Context, t Client, domainID, token str
 		return Client{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Client{}, sdkErr
 	}
 
 	t = Client{}
@@ -160,9 +160,9 @@ func (sdk mgSDK) UpdateClientTags(ctx context.Context, t Client, domainID, token
 
 	url := fmt.Sprintf("%s/%s/%s/%s/tags", sdk.clientsURL, domainID, clientsEndpoint, t.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Client{}, sdkErr
 	}
 
 	t = Client{}
@@ -183,9 +183,9 @@ func (sdk mgSDK) UpdateClientSecret(ctx context.Context, id, secret, domainID, t
 
 	url := fmt.Sprintf("%s/%s/%s/%s/secret", sdk.clientsURL, domainID, clientsEndpoint, id)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Client{}, sdkErr
 	}
 
 	var t Client
@@ -207,9 +207,9 @@ func (sdk mgSDK) DisableClient(ctx context.Context, id, domainID, token string)
 func (sdk mgSDK) changeClientStatus(ctx context.Context, id, status, domainID, token string) (Client, errors.SDKError) {
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint, id, status)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Client{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Client{}, sdkErr
 	}
 
 	t := Client{}
@@ -228,22 +228,22 @@ func (sdk mgSDK) SetClientParent(ctx context.Context, id, domainID, groupID, tok
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint, id, parentEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) RemoveClientParent(ctx context.Context, id, domainID, groupID, token string) errors.SDKError {
-	rcpg := parentGroupReq{ParentGroupID: groupID}
-	data, err := json.Marshal(rcpg)
+	pgr := parentGroupReq{ParentGroupID: groupID}
+	data, err := json.Marshal(pgr)
 	if err != nil {
 		return errors.NewSDKError(err)
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint, id, parentEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) DeleteClient(ctx context.Context, id, domainID, token string) errors.SDKError {
@@ -251,8 +251,8 @@ func (sdk mgSDK) DeleteClient(ctx context.Context, id, domainID, token string) e
 		return errors.NewSDKError(apiutil.ErrMissingID)
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.clientsURL, domainID, clientsEndpoint, id)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
-	return sdkerr
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	return sdkErr
 }
 
 func (sdk mgSDK) CreateClientRole(ctx context.Context, id, domainID string, rq RoleReq, token string) (Role, errors.SDKError) {

pkg/sdk/domains.go

@@ -45,9 +45,9 @@ func (sdk mgSDK) CreateDomain(ctx context.Context, domain Domain, token string)
 
 	url := fmt.Sprintf("%s/%s", sdk.domainsURL, domainsEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Domain{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Domain{}, sdkErr
 	}
 
 	var d Domain
@@ -63,9 +63,9 @@ func (sdk mgSDK) Domains(ctx context.Context, pm PageMetadata, token string) (Do
 		return DomainsPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return DomainsPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return DomainsPage{}, sdkErr
 	}
 
 	var dp DomainsPage
@@ -82,9 +82,9 @@ func (sdk mgSDK) Domain(ctx context.Context, domainID, token string) (Domain, er
 	}
 	url := fmt.Sprintf("%s/%s/%s", sdk.domainsURL, domainsEndpoint, domainID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Domain{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Domain{}, sdkErr
 	}
 
 	var domain Domain
@@ -106,9 +106,9 @@ func (sdk mgSDK) UpdateDomain(ctx context.Context, domain Domain, token string)
 		return Domain{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Domain{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Domain{}, sdkErr
 	}
 
 	var d Domain
@@ -132,8 +132,8 @@ func (sdk mgSDK) FreezeDomain(ctx context.Context, domainID, token string) error
 
 func (sdk mgSDK) changeDomainStatus(ctx context.Context, token, id, status string) errors.SDKError {
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, id, status)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
-	return sdkerr
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
+	return sdkErr
 }
 
 func (sdk mgSDK) CreateDomainRole(ctx context.Context, id string, rq RoleReq, token string) (Role, errors.SDKError) {

pkg/sdk/groups.go

@@ -59,9 +59,9 @@ func (sdk mgSDK) CreateGroup(ctx context.Context, g Group, domainID, token strin
 	}
 	url := fmt.Sprintf("%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Group{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Group{}, sdkErr
 	}
 
 	g = Group{}
@@ -79,9 +79,9 @@ func (sdk mgSDK) Groups(ctx context.Context, pm PageMetadata, domainID, token st
 		return GroupsPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return GroupsPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return GroupsPage{}, sdkErr
 	}
 
 	gp := GroupsPage{}
@@ -99,9 +99,9 @@ func (sdk mgSDK) Group(ctx context.Context, id, domainID, token string) (Group,
 
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Group{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Group{}, sdkErr
 	}
 
 	var t Group
@@ -123,9 +123,9 @@ func (sdk mgSDK) UpdateGroup(ctx context.Context, g Group, domainID, token strin
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, g.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPut, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Group{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPut, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Group{}, sdkErr
 	}
 
 	g = Group{}
@@ -147,9 +147,9 @@ func (sdk mgSDK) UpdateGroupTags(ctx context.Context, g Group, domainID, token s
 		return Group{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Group{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Group{}, sdkErr
 	}
 
 	g = Group{}
@@ -168,22 +168,22 @@ func (sdk mgSDK) SetGroupParent(ctx context.Context, id, domainID, groupID, toke
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id, parentEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) RemoveGroupParent(ctx context.Context, id, domainID, groupID, token string) errors.SDKError {
-	rcpg := groupParentReq{ParentID: groupID}
-	data, err := json.Marshal(rcpg)
+	pgr := groupParentReq{ParentID: groupID}
+	data, err := json.Marshal(pgr)
 	if err != nil {
 		return errors.NewSDKError(err)
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id, parentEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) AddChildren(ctx context.Context, id, domainID string, groupIDs []string, token string) errors.SDKError {
@@ -194,9 +194,9 @@ func (sdk mgSDK) AddChildren(ctx context.Context, id, domainID string, groupIDs
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id, childrenEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) RemoveChildren(ctx context.Context, id, domainID string, groupIDs []string, token string) errors.SDKError {
@@ -207,16 +207,16 @@ func (sdk mgSDK) RemoveChildren(ctx context.Context, id, domainID string, groupI
 	}
 
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id, childrenEndpoint)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) RemoveAllChildren(ctx context.Context, id, domainID, token string) errors.SDKError {
 	url := fmt.Sprintf("%s/%s/%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id, childrenEndpoint, "all")
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) Children(ctx context.Context, id, domainID string, pm PageMetadata, token string) (GroupsPage, errors.SDKError) {
@@ -226,9 +226,9 @@ func (sdk mgSDK) Children(ctx context.Context, id, domainID string, pm PageMetad
 		return GroupsPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return GroupsPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return GroupsPage{}, sdkErr
 	}
 
 	gp := GroupsPage{}
@@ -250,9 +250,9 @@ func (sdk mgSDK) DisableGroup(ctx context.Context, id, domainID, token string) (
 func (sdk mgSDK) changeGroupStatus(ctx context.Context, id, status, domainID, token string) (Group, errors.SDKError) {
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id, status)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Group{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Group{}, sdkErr
 	}
 	g := Group{}
 	if err := json.Unmarshal(body, &g); err != nil {
@@ -267,8 +267,8 @@ func (sdk mgSDK) DeleteGroup(ctx context.Context, id, domainID, token string) er
 		return errors.NewSDKError(apiutil.ErrMissingID)
 	}
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.groupsURL, domainID, groupsEndpoint, id)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
-	return sdkerr
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	return sdkErr
 }
 
 func (sdk mgSDK) Hierarchy(ctx context.Context, id, domainID string, pm PageMetadata, token string) (GroupsHierarchyPage, errors.SDKError) {
@@ -278,9 +278,9 @@ func (sdk mgSDK) Hierarchy(ctx context.Context, id, domainID string, pm PageMeta
 		return GroupsHierarchyPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return GroupsHierarchyPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return GroupsHierarchyPage{}, sdkErr
 	}
 
 	hp := GroupsHierarchyPage{}

pkg/sdk/invitations.go

@@ -49,17 +49,17 @@ func (sdk mgSDK) SendInvitation(ctx context.Context, invitation Invitation, toke
 
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, invitation.DomainID, invitationsEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) Invitation(ctx context.Context, userID, domainID, token string) (invitation Invitation, err error) {
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, domainID, invitationsEndpoint, userID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Invitation{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Invitation{}, sdkErr
 	}
 
 	if err := json.Unmarshal(body, &invitation); err != nil {
@@ -95,9 +95,9 @@ func (sdk mgSDK) Invitations(ctx context.Context, pm PageMetadata, token string)
 		return InvitationPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return InvitationPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return InvitationPage{}, sdkErr
 	}
 
 	var invPage InvitationPage
@@ -121,9 +121,9 @@ func (sdk mgSDK) AcceptInvitation(ctx context.Context, domainID, token string) (
 
 	url := fmt.Sprintf("%s/%s/%s", sdk.domainsURL, invitationsEndpoint, acceptEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) RejectInvitation(ctx context.Context, domainID, token string) (err error) {
@@ -139,15 +139,15 @@ func (sdk mgSDK) RejectInvitation(ctx context.Context, domainID, token string) (
 
 	url := fmt.Sprintf("%s/%s/%s", sdk.domainsURL, invitationsEndpoint, rejectEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) DeleteInvitation(ctx context.Context, userID, domainID, token string) (err error) {
 	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, domainID, invitationsEndpoint, userID)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }

pkg/sdk/journal.go

@@ -49,9 +49,9 @@ func (sdk mgSDK) Journal(ctx context.Context, entityType, entityID, domainID str
 		return JournalsPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return JournalsPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return JournalsPage{}, sdkErr
 	}
 
 	var journalsPage JournalsPage

pkg/sdk/roles.go

@@ -22,9 +22,9 @@ func (sdk mgSDK) createRole(ctx context.Context, entityURL, entityEndpoint, id,
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Role{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Role{}, sdkErr
 	}
 
 	role := Role{}
@@ -45,9 +45,9 @@ func (sdk mgSDK) listRoles(ctx context.Context, entityURL, entityEndpoint, id, d
 		return RolesPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return RolesPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return RolesPage{}, sdkErr
 	}
 
 	var rp RolesPage
@@ -63,9 +63,9 @@ func (sdk mgSDK) viewRole(ctx context.Context, entityURL, entityEndpoint, id, ro
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Role{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Role{}, sdkErr
 	}
 
 	var role Role
@@ -87,9 +87,9 @@ func (sdk mgSDK) updateRole(ctx context.Context, entityURL, entityEndpoint, id,
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPut, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return Role{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPut, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return Role{}, sdkErr
 	}
 
 	role := Role{}
@@ -105,9 +105,9 @@ func (sdk mgSDK) deleteRole(ctx context.Context, entityURL, entityEndpoint, id,
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID)
 	}
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) addRoleActions(ctx context.Context, entityURL, entityEndpoint, id, roleID, domainID string, actions []string, token string) ([]string, errors.SDKError) {
@@ -121,9 +121,9 @@ func (sdk mgSDK) addRoleActions(ctx context.Context, entityURL, entityEndpoint,
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, actionsEndpoint)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return []string{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return []string{}, sdkErr
 	}
 
 	res := roleActionsRes{}
@@ -139,9 +139,9 @@ func (sdk mgSDK) listRoleActions(ctx context.Context, entityURL, entityEndpoint,
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, actionsEndpoint)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return nil, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return nil, sdkErr
 	}
 
 	res := roleActionsRes{}
@@ -163,9 +163,9 @@ func (sdk mgSDK) removeRoleActions(ctx context.Context, entityURL, entityEndpoin
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, actionsEndpoint, "delete")
 	}
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) removeAllRoleActions(ctx context.Context, entityURL, entityEndpoint, id, roleID, domainID, token string) errors.SDKError {
@@ -173,9 +173,9 @@ func (sdk mgSDK) removeAllRoleActions(ctx context.Context, entityURL, entityEndp
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, actionsEndpoint, "delete-all")
 	}
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) addRoleMembers(ctx context.Context, entityURL, entityEndpoint, id, roleID, domainID string, members []string, token string) ([]string, errors.SDKError) {
@@ -189,9 +189,9 @@ func (sdk mgSDK) addRoleMembers(ctx context.Context, entityURL, entityEndpoint,
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, membersEndpoint)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return []string{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return []string{}, sdkErr
 	}
 
 	res := roleMembersRes{}
@@ -211,9 +211,9 @@ func (sdk mgSDK) listRoleMembers(ctx context.Context, entityURL, entityEndpoint,
 	if err != nil {
 		return RoleMembersPage{}, errors.NewSDKError(err)
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return RoleMembersPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return RoleMembersPage{}, sdkErr
 	}
 
 	res := RoleMembersPage{}
@@ -235,9 +235,9 @@ func (sdk mgSDK) removeRoleMembers(ctx context.Context, entityURL, entityEndpoin
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, membersEndpoint, "delete")
 	}
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) removeAllRoleMembers(ctx context.Context, entityURL, entityEndpoint, id, roleID, domainID, token string) errors.SDKError {
@@ -245,9 +245,9 @@ func (sdk mgSDK) removeAllRoleMembers(ctx context.Context, entityURL, entityEndp
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s/%s/%s/%s", entityURL, entityEndpoint, id, rolesEndpoint, roleID, membersEndpoint, "delete-all")
 	}
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusNoContent)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusNoContent)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) listAvailableRoleActions(ctx context.Context, entityURL, entityEndpoint, domainID, token string) ([]string, errors.SDKError) {
@@ -255,9 +255,9 @@ func (sdk mgSDK) listAvailableRoleActions(ctx context.Context, entityURL, entity
 	if entityEndpoint == domainsEndpoint {
 		url = fmt.Sprintf("%s/%s/%s/%s", entityURL, entityEndpoint, rolesEndpoint, "available-actions")
 	}
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return nil, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return nil, sdkErr
 	}
 
 	res := availableRoleActionsRes{}
@@ -278,9 +278,9 @@ func (sdk mgSDK) listEntityMembers(ctx context.Context, entityURL, domainID, ent
 		return EntityMembersPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return EntityMembersPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return EntityMembersPage{}, sdkErr
 	}
 
 	res := EntityMembersPage{}

pkg/sdk/sdk.go

@@ -1437,9 +1437,9 @@ func (sdk mgSDK) processRequest(ctx context.Context, method, reqUrl, token strin
 	}
 	defer resp.Body.Close()
 
-	sdkerr := errors.CheckError(resp, expectedRespCodes...)
-	if sdkerr != nil {
-		return make(http.Header), []byte{}, sdkerr
+	sdkErr := errors.CheckError(resp, expectedRespCodes...)
+	if sdkErr != nil {
+		return make(http.Header), []byte{}, sdkErr
 	}
 
 	body, err := io.ReadAll(resp.Body)

pkg/sdk/tokens.go

@@ -33,9 +33,9 @@ func (sdk mgSDK) CreateToken(ctx context.Context, lt Login) (Token, errors.SDKEr
 
 	url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, usersEndpoint, issueTokenEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, "", data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Token{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, "", data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Token{}, sdkErr
 	}
 	var token Token
 	if err := json.Unmarshal(body, &token); err != nil {
@@ -48,9 +48,9 @@ func (sdk mgSDK) CreateToken(ctx context.Context, lt Login) (Token, errors.SDKEr
 func (sdk mgSDK) RefreshToken(ctx context.Context, token string) (Token, errors.SDKError) {
 	url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, usersEndpoint, refreshTokenEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return Token{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return Token{}, sdkErr
 	}
 
 	t := Token{}

pkg/sdk/users.go

@@ -48,9 +48,9 @@ func (sdk mgSDK) CreateUser(ctx context.Context, user User, token string) (User,
 
 	url := fmt.Sprintf("%s/%s", sdk.usersURL, usersEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, data, nil, http.StatusCreated)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -67,9 +67,9 @@ func (sdk mgSDK) Users(ctx context.Context, pm PageMetadata, token string) (User
 		return UsersPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return UsersPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return UsersPage{}, sdkErr
 	}
 
 	var cp UsersPage
@@ -86,9 +86,9 @@ func (sdk mgSDK) User(ctx context.Context, id, token string) (User, errors.SDKEr
 	}
 	url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, usersEndpoint, id)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	var user User
@@ -102,9 +102,9 @@ func (sdk mgSDK) User(ctx context.Context, id, token string) (User, errors.SDKEr
 func (sdk mgSDK) UserProfile(ctx context.Context, token string) (User, errors.SDKError) {
 	url := fmt.Sprintf("%s/%s/profile", sdk.usersURL, usersEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	var user User
@@ -126,9 +126,9 @@ func (sdk mgSDK) UpdateUser(ctx context.Context, user User, token string) (User,
 		return User{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -147,9 +147,9 @@ func (sdk mgSDK) UpdateUserTags(ctx context.Context, user User, token string) (U
 
 	url := fmt.Sprintf("%s/%s/%s/tags", sdk.usersURL, usersEndpoint, user.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -170,9 +170,9 @@ func (sdk mgSDK) UpdateUserEmail(ctx context.Context, user User, token string) (
 
 	url := fmt.Sprintf("%s/%s/%s/email", sdk.usersURL, usersEndpoint, user.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -195,9 +195,9 @@ func (sdk mgSDK) ResetPasswordRequest(ctx context.Context, email string) errors.
 	header := make(map[string]string)
 	header["Referer"] = sdk.HostURL
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, "", data, header, http.StatusCreated)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, "", data, header, http.StatusCreated)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) ResetPassword(ctx context.Context, password, confPass, token string) errors.SDKError {
@@ -209,9 +209,9 @@ func (sdk mgSDK) ResetPassword(ctx context.Context, password, confPass, token st
 	}
 	url := fmt.Sprintf("%s/%s/reset", sdk.usersURL, PasswordResetEndpoint)
 
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodPut, url, token, data, nil, http.StatusCreated)
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodPut, url, token, data, nil, http.StatusCreated)
 
-	return sdkerr
+	return sdkErr
 }
 
 func (sdk mgSDK) UpdatePassword(ctx context.Context, oldPass, newPass, token string) (User, errors.SDKError) {
@@ -224,9 +224,9 @@ func (sdk mgSDK) UpdatePassword(ctx context.Context, oldPass, newPass, token str
 
 	url := fmt.Sprintf("%s/%s/secret", sdk.usersURL, usersEndpoint)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	var user User
@@ -245,9 +245,9 @@ func (sdk mgSDK) UpdateUserRole(ctx context.Context, user User, token string) (U
 
 	url := fmt.Sprintf("%s/%s/%s/role", sdk.usersURL, usersEndpoint, user.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -267,9 +267,9 @@ func (sdk mgSDK) UpdateUsername(ctx context.Context, user User, token string) (U
 
 	url := fmt.Sprintf("%s/%s/%s/username", sdk.usersURL, usersEndpoint, user.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -288,9 +288,9 @@ func (sdk mgSDK) UpdateProfilePicture(ctx context.Context, user User, token stri
 
 	url := fmt.Sprintf("%s/%s/%s/picture", sdk.usersURL, usersEndpoint, user.ID)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user = User{}
@@ -307,9 +307,9 @@ func (sdk mgSDK) SearchUsers(ctx context.Context, pm PageMetadata, token string)
 		return UsersPage{}, errors.NewSDKError(err)
 	}
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return UsersPage{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return UsersPage{}, sdkErr
 	}
 
 	var cp UsersPage
@@ -331,9 +331,9 @@ func (sdk mgSDK) DisableUser(ctx context.Context, id, token string) (User, error
 func (sdk mgSDK) changeUserStatus(ctx context.Context, token, id, status string) (User, errors.SDKError) {
 	url := fmt.Sprintf("%s/%s/%s/%s", sdk.usersURL, usersEndpoint, id, status)
 
-	_, body, sdkerr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
-	if sdkerr != nil {
-		return User{}, sdkerr
+	_, body, sdkErr := sdk.processRequest(ctx, http.MethodPost, url, token, nil, nil, http.StatusOK)
+	if sdkErr != nil {
+		return User{}, sdkErr
 	}
 
 	user := User{}
@@ -349,6 +349,6 @@ func (sdk mgSDK) DeleteUser(ctx context.Context, id, token string) errors.SDKErr
 		return errors.NewSDKError(apiutil.ErrMissingID)
 	}
 	url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, usersEndpoint, id)
-	_, _, sdkerr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
-	return sdkerr
+	_, _, sdkErr := sdk.processRequest(ctx, http.MethodDelete, url, token, nil, nil, http.StatusNoContent)
+	return sdkErr
 }

pkg/svcutil/externaloperationperm.go

@@ -28,8 +28,8 @@ func NewExternalOperationPerm(expectedOps []ExternalOperation, opNames []string)
 	}
 }
 
-func (eopp ExternalOperationPerm) isKeyRequired(eop ExternalOperation) bool {
-	for _, key := range eopp.expectedOps {
+func (req ExternalOperationPerm) isKeyRequired(eop ExternalOperation) bool {
+	for _, key := range req.expectedOps {
 		if key == eop {
 			return true
 		}
@@ -37,44 +37,44 @@ func (eopp ExternalOperationPerm) isKeyRequired(eop ExternalOperation) bool {
 	return false
 }
 
-func (eopp ExternalOperationPerm) AddOperationPermissionMap(eopMap map[ExternalOperation]Permission) error {
+func (req ExternalOperationPerm) AddOperationPermissionMap(eopMap map[ExternalOperation]Permission) error {
 	// First iteration check all the keys are valid, If any one key is invalid then no key should be added.
 	for eop := range eopMap {
-		if !eopp.isKeyRequired(eop) {
-			return fmt.Errorf("%v is not a valid external operation", eop.String(eopp.opNames))
+		if !req.isKeyRequired(eop) {
+			return fmt.Errorf("%v is not a valid external operation", eop.String(req.opNames))
 		}
 	}
 	for eop, perm := range eopMap {
-		eopp.opPerm[eop] = perm
+		req.opPerm[eop] = perm
 	}
 	return nil
 }
 
-func (eopp ExternalOperationPerm) AddOperationPermission(eop ExternalOperation, perm Permission) error {
-	if !eopp.isKeyRequired(eop) {
-		return fmt.Errorf("%v is not a valid external operation", eop.String(eopp.opNames))
+func (req ExternalOperationPerm) AddOperationPermission(eop ExternalOperation, perm Permission) error {
+	if !req.isKeyRequired(eop) {
+		return fmt.Errorf("%v is not a valid external operation", eop.String(req.opNames))
 	}
-	eopp.opPerm[eop] = perm
+	req.opPerm[eop] = perm
 	return nil
 }
 
-func (eopp ExternalOperationPerm) Validate() error {
-	for eop := range eopp.opPerm {
-		if !eopp.isKeyRequired(eop) {
-			return fmt.Errorf("ExternalOperationPerm: \"%s\" is not a valid external operation", eop.String(eopp.opNames))
+func (req ExternalOperationPerm) Validate() error {
+	for eop := range req.opPerm {
+		if !req.isKeyRequired(eop) {
+			return fmt.Errorf("ExternalOperationPerm: \"%s\" is not a valid external operation", eop.String(req.opNames))
 		}
 	}
-	for _, eeo := range eopp.expectedOps {
-		if _, ok := eopp.opPerm[eeo]; !ok {
-			return fmt.Errorf("ExternalOperationPerm: \"%s\" external operation is missing", eeo.String(eopp.opNames))
+	for _, eeo := range req.expectedOps {
+		if _, ok := req.opPerm[eeo]; !ok {
+			return fmt.Errorf("ExternalOperationPerm: \"%s\" external operation is missing", eeo.String(req.opNames))
 		}
 	}
 	return nil
 }
 
-func (eopp ExternalOperationPerm) GetPermission(eop ExternalOperation) (Permission, error) {
-	if perm, ok := eopp.opPerm[eop]; ok {
+func (req ExternalOperationPerm) GetPermission(eop ExternalOperation) (Permission, error) {
+	if perm, ok := req.opPerm[eop]; ok {
 		return perm, nil
 	}
-	return "", fmt.Errorf("external operation \"%s\" doesn't have any permissions", eop.String(eopp.opNames))
+	return "", fmt.Errorf("external operation \"%s\" doesn't have any permissions", eop.String(req.opNames))
 }

users/api/endpoints.go

@@ -250,7 +250,7 @@ func updateEmailEndpoint(svc users.Service) endpoint.Endpoint {
 // must be sent as PUT request to 'password/reset' passwordResetEndpoint.
 func passwordResetRequestEndpoint(svc users.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(passwResetReq)
+		req := request.(passResetReq)
 		if err := req.validate(); err != nil {
 			return nil, errors.Wrap(apiutil.ErrValidation, err)
 		}
@@ -259,7 +259,7 @@ func passwordResetRequestEndpoint(svc users.Service) endpoint.Endpoint {
 			return nil, err
 		}
 
-		return passwResetReqRes{Msg: MailSent}, nil
+		return passResetReqRes{Msg: MailSent}, nil
 	}
 }
 
@@ -281,7 +281,7 @@ func passwordResetEndpoint(svc users.Service) endpoint.Endpoint {
 			return nil, err
 		}
 
-		return passwChangeRes{}, nil
+		return passChangeRes{}, nil
 	}
 }
 

users/api/requests.go

@@ -275,12 +275,12 @@ func (req tokenReq) validate() error {
 	return nil
 }
 
-type passwResetReq struct {
+type passResetReq struct {
 	Email string `json:"email"`
 	Host  string `json:"host"`
 }
 
-func (req passwResetReq) validate() error {
+func (req passResetReq) validate() error {
 	if req.Email == "" {
 		return apiutil.ErrMissingEmail
 	}

users/api/requests_test.go

@@ -580,12 +580,12 @@ func TestTokenReqValidate(t *testing.T) {
 func TestPasswResetReqValidate(t *testing.T) {
 	cases := []struct {
 		desc string
-		req  passwResetReq
+		req  passResetReq
 		err  error
 	}{
 		{
 			desc: "valid request",
-			req: passwResetReq{
+			req: passResetReq{
 				Email: "example@example.com",
 				Host:  "example.com",
 			},
@@ -593,7 +593,7 @@ func TestPasswResetReqValidate(t *testing.T) {
 		},
 		{
 			desc: "empty email",
-			req: passwResetReq{
+			req: passResetReq{
 				Email: "",
 				Host:  "example.com",
 			},
@@ -601,7 +601,7 @@ func TestPasswResetReqValidate(t *testing.T) {
 		},
 		{
 			desc: "empty host",
-			req: passwResetReq{
+			req: passResetReq{
 				Email: "example@example.com",
 				Host:  "",
 			},

users/api/responses.go

@@ -21,8 +21,8 @@ var (
 	_ supermq.Response = (*changeUserStatusRes)(nil)
 	_ supermq.Response = (*usersPageRes)(nil)
 	_ supermq.Response = (*viewMembersRes)(nil)
-	_ supermq.Response = (*passwResetReqRes)(nil)
-	_ supermq.Response = (*passwChangeRes)(nil)
+	_ supermq.Response = (*passResetReqRes)(nil)
+	_ supermq.Response = (*passChangeRes)(nil)
 	_ supermq.Response = (*updateUserRes)(nil)
 	_ supermq.Response = (*tokenRes)(nil)
 	_ supermq.Response = (*deleteUserRes)(nil)
@@ -160,33 +160,33 @@ func (res changeUserStatusRes) Empty() bool {
 	return false
 }
 
-type passwResetReqRes struct {
+type passResetReqRes struct {
 	Msg string `json:"msg"`
 }
 
-func (res passwResetReqRes) Code() int {
+func (res passResetReqRes) Code() int {
 	return http.StatusCreated
 }
 
-func (res passwResetReqRes) Headers() map[string]string {
+func (res passResetReqRes) Headers() map[string]string {
 	return map[string]string{}
 }
 
-func (res passwResetReqRes) Empty() bool {
+func (res passResetReqRes) Empty() bool {
 	return false
 }
 
-type passwChangeRes struct{}
+type passChangeRes struct{}
 
-func (res passwChangeRes) Code() int {
+func (res passChangeRes) Code() int {
 	return http.StatusCreated
 }
 
-func (res passwChangeRes) Headers() map[string]string {
+func (res passChangeRes) Headers() map[string]string {
 	return map[string]string{}
 }
 
-func (res passwChangeRes) Empty() bool {
+func (res passChangeRes) Empty() bool {
 	return false
 }
 

users/api/users.go

@@ -436,7 +436,7 @@ func decodePasswordResetRequest(_ context.Context, r *http.Request) (interface{}
 		return nil, apiutil.ErrUnsupportedContentType
 	}
 
-	var req passwResetReq
+	var req passResetReq
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		return nil, errors.Wrap(apiutil.ErrValidation, errors.Wrap(err, errors.ErrMalformedEntity))
 	}

users/events/events.go

@@ -185,21 +185,21 @@ type updateProfilePictureEvent struct {
 	requestID string
 }
 
-func (uppe updateProfilePictureEvent) Encode() (map[string]interface{}, error) {
+func (req updateProfilePictureEvent) Encode() (map[string]interface{}, error) {
 	val := map[string]interface{}{
 		"operation":   userUpdateProfilePicture,
-		"updated_at":  uppe.UpdatedAt,
-		"updated_by":  uppe.UpdatedBy,
-		"token_type":  uppe.Type.String(),
-		"super_admin": uppe.SuperAdmin,
-		"request_id":  uppe.requestID,
+		"updated_at":  req.UpdatedAt,
+		"updated_by":  req.UpdatedBy,
+		"token_type":  req.Type.String(),
+		"super_admin": req.SuperAdmin,
+		"request_id":  req.requestID,
 	}
 
-	if uppe.ID != "" {
-		val["id"] = uppe.ID
+	if req.ID != "" {
+		val["id"] = req.ID
 	}
-	if uppe.ProfilePicture != "" {
-		val["profile_picture"] = uppe.ProfilePicture
+	if req.ProfilePicture != "" {
+		val["profile_picture"] = req.ProfilePicture
 	}
 
 	return val, nil
@@ -428,12 +428,12 @@ type generateResetTokenEvent struct {
 	requestID string
 }
 
-func (grte generateResetTokenEvent) Encode() (map[string]interface{}, error) {
+func (req generateResetTokenEvent) Encode() (map[string]interface{}, error) {
 	return map[string]interface{}{
 		"operation":  generateResetToken,
-		"email":      grte.email,
-		"host":       grte.host,
-		"request_id": grte.requestID,
+		"email":      req.email,
+		"host":       req.host,
+		"request_id": req.requestID,
 	}, nil
 }
 
@@ -479,13 +479,13 @@ type sendPasswordResetEvent struct {
 	requestID string
 }
 
-func (spre sendPasswordResetEvent) Encode() (map[string]interface{}, error) {
+func (req sendPasswordResetEvent) Encode() (map[string]interface{}, error) {
 	return map[string]interface{}{
 		"operation":  sendPasswordReset,
-		"host":       spre.host,
-		"email":      spre.email,
-		"user":       spre.user,
-		"request_id": spre.requestID,
+		"host":       req.host,
+		"email":      req.email,
+		"user":       req.user,
+		"request_id": req.requestID,
 	}, nil
 }
 
@@ -525,13 +525,13 @@ type addUserPolicyEvent struct {
 	requestID string
 }
 
-func (acpe addUserPolicyEvent) Encode() (map[string]interface{}, error) {
+func (req addUserPolicyEvent) Encode() (map[string]interface{}, error) {
 	return map[string]interface{}{
 		"operation":   addClientPolicy,
-		"id":          acpe.id,
-		"role":        acpe.role,
-		"token_type":  acpe.Type.String(),
-		"super_admin": acpe.SuperAdmin,
-		"request_id":  acpe.requestID,
+		"id":          req.id,
+		"role":        req.role,
+		"token_type":  req.Type.String(),
+		"super_admin": req.SuperAdmin,
+		"request_id":  req.requestID,
 	}, nil
 }

users/service.go

@@ -464,11 +464,11 @@ func (svc *service) checkSuperAdmin(ctx context.Context, session authn.Session)
 }
 
 func (svc service) OAuthCallback(ctx context.Context, user User) (User, error) {
-	ruser, err := svc.users.RetrieveByEmail(ctx, user.Email)
+	u, err := svc.users.RetrieveByEmail(ctx, user.Email)
 	if err != nil {
 		switch errors.Contains(err, repoerr.ErrNotFound) {
 		case true:
-			ruser, err = svc.Register(ctx, authn.Session{}, user, true)
+			u, err = svc.Register(ctx, authn.Session{}, user, true)
 			if err != nil {
 				return User{}, err
 			}
@@ -478,8 +478,8 @@ func (svc service) OAuthCallback(ctx context.Context, user User) (User, error) {
 	}
 
 	return User{
-		ID:   ruser.ID,
-		Role: ruser.Role,
+		ID:   u.ID,
+		Role: u.Role,
 	}, nil
 }
 

ws/adapter_test.go

@@ -203,10 +203,10 @@ func TestSubscribe(t *testing.T) {
 			ChannelId:  tc.chanID,
 			DomainId:   tc.domainID,
 		}).Return(tc.authZRes, tc.authZErr)
-		repocall := pubsub.On("Subscribe", mock.Anything, subConfig).Return(tc.subErr)
+		repoCall := pubsub.On("Subscribe", mock.Anything, subConfig).Return(tc.subErr)
 		err := svc.Subscribe(context.Background(), sessionID, tc.clientKey, tc.domainID, tc.chanID, tc.subtopic, c)
 		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
-		repocall.Unset()
+		repoCall.Unset()
 		clientsCall.Unset()
 		channelsCall.Unset()
 	}