refactor(provisionmanage.go): make RemoveMemberDomain generic

Signed-off-by: Felix Gateru <felix.gateru@gmail.com>

channels/mocks/repository.go

@@ -909,6 +909,69 @@ func (_c *Repository_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx co
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Repository
+func (_mock *Repository) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Repository_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Repository_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RemoveMemberFromDomain_Call {
+	return &Repository_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Return(err error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveParentGroup provides a mock function for the type Repository
 func (_mock *Repository) RemoveParentGroup(ctx context.Context, ch channels.Channel) error {
 	ret := _mock.Called(ctx, ch)
@@ -1659,6 +1722,150 @@ func (_c *Repository_RetrieveRole_Call) RunAndReturn(run func(ctx context.Contex
 	return _c
 }
 
+// RetrieveRoleByDomainMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByDomainMember(ctx context.Context, domainID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByDomainMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, domainID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByDomainMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByDomainMember'
+type Repository_RetrieveRoleByDomainMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByDomainMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByDomainMember(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RetrieveRoleByDomainMember_Call {
+	return &Repository_RetrieveRoleByDomainMember_Call{Call: _e.mock.On("RetrieveRoleByDomainMember", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Return(s string, err error) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) (string, error)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RetrieveRoleByEntityMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByEntityMember(ctx context.Context, entityID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, entityID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByEntityMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, entityID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByEntityMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByEntityMember'
+type Repository_RetrieveRoleByEntityMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByEntityMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - entityID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByEntityMember(ctx interface{}, entityID interface{}, memberID interface{}) *Repository_RetrieveRoleByEntityMember_Call {
+	return &Repository_RetrieveRoleByEntityMember_Call{Call: _e.mock.On("RetrieveRoleByEntityMember", ctx, entityID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Run(run func(ctx context.Context, entityID string, memberID string)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Return(s string, err error) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) RunAndReturn(run func(ctx context.Context, entityID string, memberID string) (string, error)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RetrieveUserChannels provides a mock function for the type Repository
 func (_mock *Repository) RetrieveUserChannels(ctx context.Context, domainID string, userID string, pm channels.Page) (channels.ChannelsPage, error) {
 	ret := _mock.Called(ctx, domainID, userID, pm)

channels/mocks/service.go

@@ -1011,6 +1011,69 @@ func (_c *Service_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx conte
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Service
+func (_mock *Service) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Service_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Service_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Service_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Service_RemoveMemberFromDomain_Call {
+	return &Service_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Return(err error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveParentGroup provides a mock function for the type Service
 func (_mock *Service) RemoveParentGroup(ctx context.Context, session authn.Session, id string) error {
 	ret := _mock.Called(ctx, session, id)

clients/mocks/repository.go

@@ -796,6 +796,69 @@ func (_c *Repository_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx co
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Repository
+func (_mock *Repository) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Repository_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Repository_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RemoveMemberFromDomain_Call {
+	return &Repository_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Return(err error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveParentGroup provides a mock function for the type Repository
 func (_mock *Repository) RemoveParentGroup(ctx context.Context, cli clients.Client) error {
 	ret := _mock.Called(ctx, cli)
@@ -1618,6 +1681,150 @@ func (_c *Repository_RetrieveRole_Call) RunAndReturn(run func(ctx context.Contex
 	return _c
 }
 
+// RetrieveRoleByDomainMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByDomainMember(ctx context.Context, domainID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByDomainMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, domainID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByDomainMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByDomainMember'
+type Repository_RetrieveRoleByDomainMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByDomainMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByDomainMember(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RetrieveRoleByDomainMember_Call {
+	return &Repository_RetrieveRoleByDomainMember_Call{Call: _e.mock.On("RetrieveRoleByDomainMember", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Return(s string, err error) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) (string, error)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RetrieveRoleByEntityMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByEntityMember(ctx context.Context, entityID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, entityID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByEntityMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, entityID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByEntityMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByEntityMember'
+type Repository_RetrieveRoleByEntityMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByEntityMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - entityID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByEntityMember(ctx interface{}, entityID interface{}, memberID interface{}) *Repository_RetrieveRoleByEntityMember_Call {
+	return &Repository_RetrieveRoleByEntityMember_Call{Call: _e.mock.On("RetrieveRoleByEntityMember", ctx, entityID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Run(run func(ctx context.Context, entityID string, memberID string)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Return(s string, err error) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) RunAndReturn(run func(ctx context.Context, entityID string, memberID string) (string, error)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RetrieveUserClients provides a mock function for the type Repository
 func (_mock *Repository) RetrieveUserClients(ctx context.Context, domainID string, userID string, pm clients.Page) (clients.ClientsPage, error) {
 	ret := _mock.Called(ctx, domainID, userID, pm)

clients/mocks/service.go

@@ -860,6 +860,69 @@ func (_c *Service_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx conte
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Service
+func (_mock *Service) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Service_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Service_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Service_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Service_RemoveMemberFromDomain_Call {
+	return &Service_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Return(err error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveParentGroup provides a mock function for the type Service
 func (_mock *Service) RemoveParentGroup(ctx context.Context, session authn.Session, id string) error {
 	ret := _mock.Called(ctx, session, id)

cmd/channels/main.go

@@ -306,7 +306,7 @@ func main() {
 	ddatabase := pg.NewDatabase(db, dbConfig, tracer)
 	drepo := dpostgres.NewRepository(ddatabase)
 
-	if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, cfg.ESURL, cfg.ESConsumerName, logger); err != nil {
+	if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, svc, cfg.ESURL, cfg.ESConsumerName, logger); err != nil {
 		logger.Error(fmt.Sprintf("failed to create domains event store : %s", err))
 		exitCode = 1
 		return

cmd/clients/main.go

@@ -307,7 +307,7 @@ func main() {
 	ddatabase := pg.NewDatabase(db, dbConfig, tracer)
 	drepo := dpostgres.NewRepository(ddatabase)
 
-	if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, cfg.ESURL, cfg.ESConsumerName, logger); err != nil {
+	if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, svc, cfg.ESURL, cfg.ESConsumerName, logger); err != nil {
 		logger.Error(fmt.Sprintf("failed to create domains event store : %s", err))
 		exitCode = 1
 		return

cmd/groups/main.go

@@ -284,7 +284,7 @@ func main() {
 	ddatabase := pg.NewDatabase(db, dbConfig, tracer)
 	drepo := dpostgres.NewRepository(ddatabase)
 
-	if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, cfg.ESURL, cfg.ESConsumerName, logger); err != nil {
+	if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, svc, cfg.ESURL, cfg.ESConsumerName, logger); err != nil {
 		logger.Error(fmt.Sprintf("failed to create domains event store : %s", err))
 		exitCode = 1
 		return

domains/mocks/repository.go

@@ -498,6 +498,69 @@ func (_c *Repository_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx co
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Repository
+func (_mock *Repository) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Repository_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Repository_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RemoveMemberFromDomain_Call {
+	return &Repository_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Return(err error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveRoles provides a mock function for the type Repository
 func (_mock *Repository) RemoveRoles(ctx context.Context, roleIDs []string) error {
 	ret := _mock.Called(ctx, roleIDs)
@@ -1255,6 +1318,150 @@ func (_c *Repository_RetrieveRole_Call) RunAndReturn(run func(ctx context.Contex
 	return _c
 }
 
+// RetrieveRoleByDomainMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByDomainMember(ctx context.Context, domainID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByDomainMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, domainID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByDomainMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByDomainMember'
+type Repository_RetrieveRoleByDomainMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByDomainMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByDomainMember(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RetrieveRoleByDomainMember_Call {
+	return &Repository_RetrieveRoleByDomainMember_Call{Call: _e.mock.On("RetrieveRoleByDomainMember", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Return(s string, err error) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) (string, error)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RetrieveRoleByEntityMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByEntityMember(ctx context.Context, entityID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, entityID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByEntityMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, entityID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByEntityMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByEntityMember'
+type Repository_RetrieveRoleByEntityMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByEntityMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - entityID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByEntityMember(ctx interface{}, entityID interface{}, memberID interface{}) *Repository_RetrieveRoleByEntityMember_Call {
+	return &Repository_RetrieveRoleByEntityMember_Call{Call: _e.mock.On("RetrieveRoleByEntityMember", ctx, entityID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Run(run func(ctx context.Context, entityID string, memberID string)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Return(s string, err error) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) RunAndReturn(run func(ctx context.Context, entityID string, memberID string) (string, error)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RoleAddActions provides a mock function for the type Repository
 func (_mock *Repository) RoleAddActions(ctx context.Context, role roles.Role, actions []string) ([]string, error) {
 	ret := _mock.Called(ctx, role, actions)

domains/mocks/service.go

@@ -1137,6 +1137,69 @@ func (_c *Service_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx conte
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Service
+func (_mock *Service) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Service_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Service_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Service_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Service_RemoveMemberFromDomain_Call {
+	return &Service_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Return(err error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveRole provides a mock function for the type Service
 func (_mock *Service) RemoveRole(ctx context.Context, session authn.Session, entityID string, roleID string) error {
 	ret := _mock.Called(ctx, session, entityID, roleID)

groups/mocks/repository.go

@@ -498,6 +498,69 @@ func (_c *Repository_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx co
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Repository
+func (_mock *Repository) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Repository_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Repository_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RemoveMemberFromDomain_Call {
+	return &Repository_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Return(err error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveRoles provides a mock function for the type Repository
 func (_mock *Repository) RemoveRoles(ctx context.Context, roleIDs []string) error {
 	ret := _mock.Called(ctx, roleIDs)
@@ -1474,6 +1537,150 @@ func (_c *Repository_RetrieveRole_Call) RunAndReturn(run func(ctx context.Contex
 	return _c
 }
 
+// RetrieveRoleByDomainMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByDomainMember(ctx context.Context, domainID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByDomainMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, domainID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByDomainMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByDomainMember'
+type Repository_RetrieveRoleByDomainMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByDomainMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByDomainMember(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RetrieveRoleByDomainMember_Call {
+	return &Repository_RetrieveRoleByDomainMember_Call{Call: _e.mock.On("RetrieveRoleByDomainMember", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Return(s string, err error) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) (string, error)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RetrieveRoleByEntityMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByEntityMember(ctx context.Context, entityID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, entityID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByEntityMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, entityID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByEntityMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByEntityMember'
+type Repository_RetrieveRoleByEntityMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByEntityMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - entityID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByEntityMember(ctx interface{}, entityID interface{}, memberID interface{}) *Repository_RetrieveRoleByEntityMember_Call {
+	return &Repository_RetrieveRoleByEntityMember_Call{Call: _e.mock.On("RetrieveRoleByEntityMember", ctx, entityID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Run(run func(ctx context.Context, entityID string, memberID string)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Return(s string, err error) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) RunAndReturn(run func(ctx context.Context, entityID string, memberID string) (string, error)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RetrieveUserGroups provides a mock function for the type Repository
 func (_mock *Repository) RetrieveUserGroups(ctx context.Context, domainID string, userID string, pm groups.PageMeta) (groups.Page, error) {
 	ret := _mock.Called(ctx, domainID, userID, pm)

groups/mocks/service.go

@@ -1209,6 +1209,69 @@ func (_c *Service_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx conte
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Service
+func (_mock *Service) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Service_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Service_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Service_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Service_RemoveMemberFromDomain_Call {
+	return &Service_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) Return(err error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Service_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Service_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveParentGroup provides a mock function for the type Service
 func (_mock *Service) RemoveParentGroup(ctx context.Context, session authn.Session, id string) error {
 	ret := _mock.Called(ctx, session, id)

pkg/domains/events/consumer/decode.go

@@ -4,7 +4,6 @@
 package consumer
 
 import (
-	"fmt"
 	"time"
 
 	"github.com/absmach/magistrala/domains"
@@ -34,6 +33,9 @@ var (
 	errCreatedBy     = errors.New("missing or invalid 'created_by'")
 	errCreatedAt     = errors.New("failed to parse 'created_at' time")
 	errUpdatedAt     = errors.New("failed to parse 'updated_at' time")
+	errEntityID      = errors.New("missing or invalid 'entity_id'")
+	errMembers       = errors.New("missing or invalid 'members'")
+	errNotString     = errors.New("not string type")
 )
 
 func ToDomains(data map[string]any) (domains.Domain, error) {
@@ -256,8 +258,21 @@ func decodeFreezeDomainEvent(data map[string]any) (domains.Domain, error) {
 	return d, nil
 }
 
-func decodeUserDeleteDomainEvent(_ map[string]any) (domains.Domain, error) {
-	return domains.Domain{}, fmt.Errorf("not implemented decode domain user delete event ")
+func decodeRemoveDomainMembersEvent(data map[string]any) (string, []string, error) {
+	entityID, ok := data["entity_id"].(string)
+	if !ok {
+		return "", nil, errors.Wrap(errRemoveDomainMembersEvent, errEntityID)
+	}
+	imems, ok := data["members"].([]any)
+	if !ok {
+		return "", nil, errors.Wrap(errRemoveDomainMembersEvent, errMembers)
+	}
+	mems, err := toStrings(imems)
+	if err != nil {
+		return "", nil, errors.Wrap(errRemoveDomainMembersEvent, err)
+	}
+
+	return entityID, mems, nil
 }
 
 func decodeDeleteDomainEvent(data map[string]any) (domains.Domain, error) {
@@ -269,3 +284,15 @@ func decodeDeleteDomainEvent(data map[string]any) (domains.Domain, error) {
 	d.ID = id
 	return d, nil
 }
+
+func toStrings(data []any) ([]string, error) {
+	var strs []string
+	for _, i := range data {
+		str, ok := i.(string)
+		if !ok {
+			return []string{}, errNotString
+		}
+		strs = append(strs, str)
+	}
+	return strs, nil
+}

pkg/domains/events/consumer/stream.go

@@ -5,7 +5,6 @@ package consumer
 
 import (
 	"context"
-	"fmt"
 	"log/slog"
 
 	"github.com/absmach/magistrala/domains"
@@ -13,38 +12,40 @@ import (
 	"github.com/absmach/magistrala/pkg/events"
 	"github.com/absmach/magistrala/pkg/events/store"
 	"github.com/absmach/magistrala/pkg/messaging"
+	"github.com/absmach/magistrala/pkg/roles"
 	rconsumer "github.com/absmach/magistrala/pkg/roles/rolemanager/events/consumer"
 )
 
 const (
 	stream = "events.magistrala.domain.*"
 
-	create     = "domain.create"
-	update     = "domain.update"
-	enable     = "domain.enable"
-	disable    = "domain.disable"
-	freeze     = "domain.freeze"
-	delete     = "domain.delete"
-	userDelete = "domain.user_delete"
+	create              = "domain.create"
+	update              = "domain.update"
+	enable              = "domain.enable"
+	disable             = "domain.disable"
+	freeze              = "domain.freeze"
+	delete              = "domain.delete"
+	removeDomainMembers = "domain.members.remove"
 )
 
 var (
-	errNoOperationKey          = errors.New("operation key is not found in event message")
-	errCreateDomainEvent       = errors.New("failed to consume domain create event")
-	errUpdateDomainEvent       = errors.New("failed to consume domain update event")
-	errEnableDomainGroupEvent  = errors.New("failed to consume domain enable event")
-	errDisableDomainGroupEvent = errors.New("failed to consume domain disable event")
-	errFreezeDomainGroupEvent  = errors.New("failed to consume domain freeze event")
-	errUserDeleteDomainEvent   = errors.New("failed to consume domain user delete event")
-	errDeleteDomainEvent       = errors.New("failed to consume domain delete event")
+	errNoOperationKey           = errors.New("operation key is not found in event message")
+	errCreateDomainEvent        = errors.New("failed to consume domain create event")
+	errUpdateDomainEvent        = errors.New("failed to consume domain update event")
+	errEnableDomainEvent        = errors.New("failed to consume domain enable event")
+	errDisableDomainEvent       = errors.New("failed to consume domain disable event")
+	errFreezeDomainEvent        = errors.New("failed to consume domain freeze event")
+	errRemoveDomainMembersEvent = errors.New("failed to consume domain remove members event")
+	errDeleteDomainEvent        = errors.New("failed to consume domain delete event")
 )
 
 type eventHandler struct {
 	repo              domains.Repository
 	rolesEventHandler rconsumer.EventHandler
+	entityRoleManager roles.RoleManager
 }
 
-func DomainsEventsSubscribe(ctx context.Context, repo domains.Repository, esURL, esConsumerName string, logger *slog.Logger) error {
+func DomainsEventsSubscribe(ctx context.Context, repo domains.Repository, roleManager roles.RoleManager, esURL, esConsumerName string, logger *slog.Logger) error {
 	subscriber, err := store.NewSubscriber(ctx, esURL, "domains-es-sub", logger)
 	if err != nil {
 		return err
@@ -53,7 +54,7 @@ func DomainsEventsSubscribe(ctx context.Context, repo domains.Repository, esURL,
 	subConfig := events.SubscriberConfig{
 		Stream:         stream,
 		Consumer:       esConsumerName,
-		Handler:        NewEventHandler(repo),
+		Handler:        NewEventHandler(repo, roleManager),
 		DeliveryPolicy: messaging.DeliverNewPolicy,
 		Ordered:        true,
 	}
@@ -61,11 +62,12 @@ func DomainsEventsSubscribe(ctx context.Context, repo domains.Repository, esURL,
 }
 
 // NewEventHandler returns new event store handler.
-func NewEventHandler(repo domains.Repository) events.EventHandler {
+func NewEventHandler(repo domains.Repository, roleManager roles.RoleManager) events.EventHandler {
 	reh := rconsumer.NewEventHandler("domain", repo)
 	return &eventHandler{
 		repo:              repo,
 		rolesEventHandler: reh,
+		entityRoleManager: roleManager,
 	}
 }
 
@@ -91,8 +93,8 @@ func (es *eventHandler) Handle(ctx context.Context, event events.Event) error {
 		return es.disableDomainHandler(ctx, msg)
 	case freeze:
 		return es.freezeDomainHandler(ctx, msg)
-	case userDelete:
-		return es.userDeleteDomainHandler(ctx, msg)
+	case removeDomainMembers:
+		return es.removeDomainMembersHandler(ctx, msg)
 	case delete:
 		return es.deleteDomainHandler(ctx, msg)
 	}
@@ -142,12 +144,12 @@ func (es *eventHandler) updateDomainHandler(ctx context.Context, data map[string
 func (es *eventHandler) enableDomainHandler(ctx context.Context, data map[string]any) error {
 	d, err := decodeEnableDomainEvent(data)
 	if err != nil {
-		return errors.Wrap(errEnableDomainGroupEvent, err)
+		return errors.Wrap(errEnableDomainEvent, err)
 	}
 
 	enabled := domains.EnabledStatus
 	if _, err := es.repo.UpdateDomain(ctx, d.ID, domains.DomainReq{Status: &enabled, UpdatedBy: &d.UpdatedBy, UpdatedAt: &d.UpdatedAt}); err != nil {
-		return errors.Wrap(errEnableDomainGroupEvent, err)
+		return errors.Wrap(errEnableDomainEvent, err)
 	}
 
 	return nil
@@ -156,12 +158,12 @@ func (es *eventHandler) enableDomainHandler(ctx context.Context, data map[string
 func (es *eventHandler) disableDomainHandler(ctx context.Context, data map[string]any) error {
 	d, err := decodeDisableDomainEvent(data)
 	if err != nil {
-		return errors.Wrap(errDisableDomainGroupEvent, err)
+		return errors.Wrap(errDisableDomainEvent, err)
 	}
 
 	disabled := domains.DisabledStatus
 	if _, err := es.repo.UpdateDomain(ctx, d.ID, domains.DomainReq{Status: &disabled, UpdatedBy: &d.UpdatedBy, UpdatedAt: &d.UpdatedAt}); err != nil {
-		return errors.Wrap(errDisableDomainGroupEvent, err)
+		return errors.Wrap(errDisableDomainEvent, err)
 	}
 
 	return nil
@@ -170,24 +172,34 @@ func (es *eventHandler) disableDomainHandler(ctx context.Context, data map[strin
 func (es *eventHandler) freezeDomainHandler(ctx context.Context, data map[string]any) error {
 	d, err := decodeFreezeDomainEvent(data)
 	if err != nil {
-		return errors.Wrap(errFreezeDomainGroupEvent, err)
+		return errors.Wrap(errFreezeDomainEvent, err)
 	}
 
 	freeze := domains.FreezeStatus
 	if _, err := es.repo.UpdateDomain(ctx, d.ID, domains.DomainReq{Status: &freeze, UpdatedBy: &d.UpdatedBy, UpdatedAt: &d.UpdatedAt}); err != nil {
-		return errors.Wrap(errFreezeDomainGroupEvent, err)
+		return errors.Wrap(errFreezeDomainEvent, err)
 	}
 
 	return nil
 }
 
-func (es *eventHandler) userDeleteDomainHandler(_ context.Context, data map[string]any) error {
-	_, err := decodeUserDeleteDomainEvent(data)
+func (es *eventHandler) removeDomainMembersHandler(ctx context.Context, data map[string]any) error {
+	domainID, memberIDs, err := decodeRemoveDomainMembersEvent(data)
 	if err != nil {
-		return errors.Wrap(errUserDeleteDomainEvent, err)
+		return errors.Wrap(errRemoveDomainMembersEvent, err)
 	}
 
-	return fmt.Errorf("not implemented user delete domain handler")
+	if err := es.repo.RemoveEntityMembers(ctx, domainID, memberIDs); err != nil {
+		return errors.Wrap(errRemoveDomainMembersEvent, err)
+	}
+
+	for _, memberID := range memberIDs {
+		if err := es.entityRoleManager.RemoveMemberFromDomain(ctx, domainID, memberID); err != nil {
+			return errors.Wrap(errRemoveDomainMembersEvent, err)
+		}
+	}
+
+	return nil
 }
 
 func (es *eventHandler) deleteDomainHandler(ctx context.Context, data map[string]any) error {

pkg/roles/mocks/repository.go

@@ -302,6 +302,69 @@ func (_c *Repository_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx co
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type Repository
+func (_mock *Repository) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// Repository_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type Repository_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RemoveMemberFromDomain_Call {
+	return &Repository_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) Return(err error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *Repository_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *Repository_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveRoles provides a mock function for the type Repository
 func (_mock *Repository) RemoveRoles(ctx context.Context, roleIDs []string) error {
 	ret := _mock.Called(ctx, roleIDs)
@@ -651,6 +714,150 @@ func (_c *Repository_RetrieveRole_Call) RunAndReturn(run func(ctx context.Contex
 	return _c
 }
 
+// RetrieveRoleByDomainMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByDomainMember(ctx context.Context, domainID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByDomainMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, domainID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByDomainMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByDomainMember'
+type Repository_RetrieveRoleByDomainMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByDomainMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByDomainMember(ctx interface{}, domainID interface{}, memberID interface{}) *Repository_RetrieveRoleByDomainMember_Call {
+	return &Repository_RetrieveRoleByDomainMember_Call{Call: _e.mock.On("RetrieveRoleByDomainMember", ctx, domainID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) Return(s string, err error) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByDomainMember_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) (string, error)) *Repository_RetrieveRoleByDomainMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RetrieveRoleByEntityMember provides a mock function for the type Repository
+func (_mock *Repository) RetrieveRoleByEntityMember(ctx context.Context, entityID string, memberID string) (string, error) {
+	ret := _mock.Called(ctx, entityID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveRoleByEntityMember")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+		return returnFunc(ctx, entityID, memberID)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+		r0 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = returnFunc(ctx, entityID, memberID)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// Repository_RetrieveRoleByEntityMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRoleByEntityMember'
+type Repository_RetrieveRoleByEntityMember_Call struct {
+	*mock.Call
+}
+
+// RetrieveRoleByEntityMember is a helper method to define mock.On call
+//   - ctx context.Context
+//   - entityID string
+//   - memberID string
+func (_e *Repository_Expecter) RetrieveRoleByEntityMember(ctx interface{}, entityID interface{}, memberID interface{}) *Repository_RetrieveRoleByEntityMember_Call {
+	return &Repository_RetrieveRoleByEntityMember_Call{Call: _e.mock.On("RetrieveRoleByEntityMember", ctx, entityID, memberID)}
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Run(run func(ctx context.Context, entityID string, memberID string)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) Return(s string, err error) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *Repository_RetrieveRoleByEntityMember_Call) RunAndReturn(run func(ctx context.Context, entityID string, memberID string) (string, error)) *Repository_RetrieveRoleByEntityMember_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RoleAddActions provides a mock function for the type Repository
 func (_mock *Repository) RoleAddActions(ctx context.Context, role roles.Role, actions []string) ([]string, error) {
 	ret := _mock.Called(ctx, role, actions)

pkg/roles/mocks/role_manager.go

@@ -411,6 +411,69 @@ func (_c *RoleManager_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx c
 	return _c
 }
 
+// RemoveMemberFromDomain provides a mock function for the type RoleManager
+func (_mock *RoleManager) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	ret := _mock.Called(ctx, domainID, memberID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMemberFromDomain")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+		r0 = returnFunc(ctx, domainID, memberID)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// RoleManager_RemoveMemberFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromDomain'
+type RoleManager_RemoveMemberFromDomain_Call struct {
+	*mock.Call
+}
+
+// RemoveMemberFromDomain is a helper method to define mock.On call
+//   - ctx context.Context
+//   - domainID string
+//   - memberID string
+func (_e *RoleManager_Expecter) RemoveMemberFromDomain(ctx interface{}, domainID interface{}, memberID interface{}) *RoleManager_RemoveMemberFromDomain_Call {
+	return &RoleManager_RemoveMemberFromDomain_Call{Call: _e.mock.On("RemoveMemberFromDomain", ctx, domainID, memberID)}
+}
+
+func (_c *RoleManager_RemoveMemberFromDomain_Call) Run(run func(ctx context.Context, domainID string, memberID string)) *RoleManager_RemoveMemberFromDomain_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *RoleManager_RemoveMemberFromDomain_Call) Return(err error) *RoleManager_RemoveMemberFromDomain_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *RoleManager_RemoveMemberFromDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, memberID string) error) *RoleManager_RemoveMemberFromDomain_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RemoveRole provides a mock function for the type RoleManager
 func (_mock *RoleManager) RemoveRole(ctx context.Context, session authn.Session, entityID string, roleID string) error {
 	ret := _mock.Called(ctx, session, entityID, roleID)

pkg/roles/provisionmanage.go

@@ -19,6 +19,7 @@ var (
 	errRemoveOptionalDeletePolicies       = errors.New("failed to delete the additional requested policies")
 	errRemoveOptionalFilterDeletePolicies = errors.New("failed to filter delete the additional requested policies")
 	errRollbackRoles                      = errors.New("failed to rollback roles")
+	errInvalidOperation                   = errors.New("invalid operation")
 )
 
 type roleProvisionerManger interface {
@@ -226,6 +227,31 @@ func (r ProvisionManageService) AddNewEntitiesRoles(ctx context.Context, domainI
 	return rp, nil
 }
 
+func (r ProvisionManageService) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	if r.entityType == policies.DomainType {
+		return errInvalidOperation
+	}
+	role, err := r.repo.RetrieveRoleByDomainMember(ctx, domainID, memberID)
+	if err != nil {
+		return errors.Wrap(svcerr.ErrRemoveEntity, err)
+	}
+
+	pr := policies.Policy{
+		ObjectType:  policies.RoleType,
+		Object:      role,
+		SubjectType: policies.UserType,
+	}
+
+	if err := r.policy.DeletePolicyFilter(ctx, pr); err != nil {
+		return errors.Wrap(svcerr.ErrDeletePolicies, err)
+	}
+
+	if err := r.repo.RemoveMemberFromDomain(ctx, domainID, memberID); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (r ProvisionManageService) AddRole(ctx context.Context, session authn.Session, entityID string, roleName string, optionalActions []string, optionalMembers []string) (retRoleProvision RoleProvision, retErr error) {
 	sid, err := r.sidProvider.ID()
 	if err != nil {
@@ -627,8 +653,26 @@ func (r ProvisionManageService) ListEntityMembers(ctx context.Context, session a
 	return mp, nil
 }
 
-func (r ProvisionManageService) RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, members []string) error {
-	if err := r.repo.RemoveEntityMembers(ctx, entityID, members); err != nil {
+func (r ProvisionManageService) RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, memberIDs []string) error {
+	deletePolicies := []policies.Policy{}
+	for _, memberID := range memberIDs {
+		roleID, err := r.repo.RetrieveRoleByEntityMember(ctx, entityID, memberID)
+		if err != nil {
+			return errors.Wrap(svcerr.ErrRemoveEntity, err)
+		}
+		deletePolicies = append(deletePolicies, policies.Policy{
+			Subject:     policies.EncodeDomainUserID(session.DomainID, memberID),
+			SubjectType: policies.UserType,
+			Relation:    policies.MemberRelation,
+			ObjectType:  policies.RoleType,
+			Object:      roleID,
+		})
+	}
+
+	if err := r.policy.DeletePolicies(ctx, deletePolicies); err != nil {
+		return errors.Wrap(svcerr.ErrDeletePolicies, err)
+	}
+	if err := r.repo.RemoveEntityMembers(ctx, entityID, memberIDs); err != nil {
 		return err
 	}
 	return nil

pkg/roles/repo/postgres/roles.go

@@ -827,11 +827,122 @@ func (repo *Repository) ListEntityMembers(ctx context.Context, entityID string,
 	}, nil
 }
 
+func (repo *Repository) RetrieveRoleByEntityMember(ctx context.Context, entityID, memberID string) (string, error) {
+	params := map[string]any{
+		"entity_id": entityID,
+		"member_id": memberID,
+	}
+
+	query := fmt.Sprintf(`SELECT role_id, entity_id, member_id FROM %s_role_members WHERE entity_id = :entity_id AND  member_id = :member_id`, repo.tableNamePrefix)
+
+	rows, err := repo.db.NamedQueryContext(ctx, query, params)
+	if err != nil {
+		return "", errors.Wrap(repoerr.ErrViewEntity, err)
+	}
+	defer rows.Close()
+
+	roleID := ""
+	for rows.Next() {
+		var dbrmem dbRoleMember
+		if err := rows.StructScan(&dbrmem); err != nil {
+			return "", errors.Wrap(repoerr.ErrViewEntity, err)
+		}
+		roleID = dbrmem.RoleID
+	}
+
+	return roleID, nil
+}
+
 func (repo *Repository) RemoveEntityMembers(ctx context.Context, entityID string, memberIDs []string) error {
+	params := map[string]any{
+		"entity_id":  entityID,
+		"member_ids": memberIDs,
+	}
+
+	query := fmt.Sprintf(`DELETE FROM %s_role_members WHERE entity_id = :entity_id AND member_id = ANY(:member_ids)`, repo.tableNamePrefix)
+
+	if _, err := repo.db.NamedExecContext(ctx, query, params); err != nil {
+		return errors.Wrap(repoerr.ErrRemoveEntity, err)
+	}
+
+	return nil
+}
+
+func (repo *Repository) RetrieveRoleByDomainMember(ctx context.Context, domainID, memberID string) (string, error) {
+	params := map[string]any{
+		"domain_id": domainID,
+		"member_id": memberID,
+	}
+
+	query := fmt.Sprintf(`
+		SELECT
+			rm.role_id,
+			rm.entity_id,
+			rm.member_id
+		FROM
+			%s_role_members rm
+		JOIN %s e ON
+			e.id = rm.entity_id
+		WHERE
+			e.domain_id = :domain_id
+			AND rm.member_id = :member_id
+		`,
+		repo.tableNamePrefix, repo.tableNamePrefix)
+
+	rows, err := repo.db.NamedQueryContext(ctx, query, params)
+	if err != nil {
+		return "", errors.Wrap(repoerr.ErrViewEntity, err)
+	}
+	defer rows.Close()
+
+	roleID := ""
+	for rows.Next() {
+		dbrmems := dbRoleMember{}
+		if err := rows.StructScan(&dbrmems); err != nil {
+			return "", errors.Wrap(repoerr.ErrViewEntity, err)
+		}
+
+		roleID = dbrmems.RoleID
+	}
+
+	return roleID, nil
+}
+
+func (repo *Repository) RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error {
+	params := map[string]any{
+		"domain_id": domainID,
+		"member_id": memberID,
+	}
+
+	query := fmt.Sprintf(`
+		DELETE
+		FROM
+			%s_role_members rm
+		JOIN %s e ON
+			e.id = rm.entity_id
+		WHERE
+			e.domain_id = :domain_id
+			AND rm.member_id = :member_id
+		`,
+		repo.tableNamePrefix, repo.tableNamePrefix)
+	if _, err := repo.db.NamedExecContext(ctx, query, params); err != nil {
+		return errors.Wrap(repoerr.ErrRemoveEntity, err)
+	}
+
 	return nil
 }
 
 func (repo *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) (err error) {
+	params := map[string]any{
+		"member_id": memberID,
+	}
+
+	query := fmt.Sprintf(`DELETE FROM %s_role_members WHERE member_id = :member_id`, repo.tableNamePrefix)
+
+	if _, err := repo.db.NamedExecContext(ctx, query, params); err != nil {
+		return errors.Wrap(repoerr.ErrRemoveEntity, err)
+	}
+
 	return nil
 }
 

pkg/roles/rolemanager/api/router.go

@@ -34,7 +34,7 @@ func EntityRoleMangerRouter(svc roles.RoleManager, d Decoder, r chi.Router, opts
 			opts...,
 		), "list_entity_members").ServeHTTP)
 
-		r.Delete("/", otelhttp.NewHandler(kithttp.NewServer(
+		r.Delete("/members", otelhttp.NewHandler(kithttp.NewServer(
 			RemoveEntityMembersEndpoint(svc),
 			d.DecodeListEntityMembers,
 			api.EncodeResponse,

pkg/roles/rolemanager/events/consumer/handler.go

@@ -82,7 +82,7 @@ func (es *EventHandler) Handle(ctx context.Context, op any, msg map[string]any)
 	case es.removeEntityMembers:
 		return es.RemoveEntityMembersHandler(ctx, msg)
 	case es.removeMemberFromAllRoles:
-		return es.RemoveMemberFromAllEntityHandler(ctx, msg)
+		return es.RemoveMemberFromAllRolesHandler(ctx, msg)
 	}
 	return nil
 }
@@ -251,13 +251,19 @@ func (es *EventHandler) RemoveEntityMembersHandler(ctx context.Context, data map
 	if err != nil {
 		return fmt.Errorf(errRemoveEntityRoleMembersEvent, es.entityType, err)
 	}
-
-	// added when repo is implemented.
-	_ = entityID
-	_ = mems
+	if err := es.repo.RemoveEntityMembers(ctx, entityID, mems); err != nil {
+		return fmt.Errorf(errRemoveEntityRoleMembersEvent, es.entityType, err)
+	}
 	return nil
 }
 
-func (es *EventHandler) RemoveMemberFromAllEntityHandler(ctx context.Context, data map[string]any) error {
+func (es *EventHandler) RemoveMemberFromAllRolesHandler(ctx context.Context, data map[string]any) error {
+	memberID, ok := data["member_id"].(string)
+	if !ok {
+		return fmt.Errorf(errRemoveEntityRoleMembersEvent, es.entityType, errMembers)
+	}
+	if err := es.repo.RemoveMemberFromAllRoles(ctx, memberID); err != nil {
+		return fmt.Errorf(errRemoveEntityRoleMembersEvent, es.entityType, err)
+	}
 	return nil
 }

pkg/roles/rolemanager/events/events.go

@@ -25,6 +25,7 @@ const (
 	CheckRoleMembers         = "role.members.check"
 	RemoveRoleMembers        = "role.members.remove"
 	RemoveRoleAllMembers     = "role.members.remove_all"
+	RemoveMemberFromDomain   = "role.domain.member.remove"
 	ListEntityMembers        = "members.list"
 	RemoveEntityMembers      = "members.remove"
 	RemoveMemberFromAllRoles = "role.members.remove_from_all_roles"
@@ -373,6 +374,23 @@ func (leme listEntityMembersEvent) Encode() (map[string]any, error) {
 	return val, nil
 }
 
+type removeMemberFromDomainEvent struct {
+	operationPrefix string
+	domainID        string
+	memberID        string
+	requestID       string
+}
+
+func (rmde removeMemberFromDomainEvent) Encode() (map[string]any, error) {
+	val := map[string]any{
+		"operation":  rmde.operationPrefix + RemoveMemberFromDomain,
+		"domain_id":  rmde.domainID,
+		"member_id":  rmde.memberID,
+		"request_id": rmde.requestID,
+	}
+	return val, nil
+}
+
 type removeEntityMembersEvent struct {
 	operationPrefix string
 	entityID        string

pkg/roles/rolemanager/events/streams.go

@@ -347,6 +347,23 @@ func (rmes *RoleManagerEventStore) ListEntityMembers(ctx context.Context, sessio
 	return mems, nil
 }
 
+func (rmes *RoleManagerEventStore) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	if err := rmes.svc.RemoveMemberFromDomain(ctx, domainID, memberID); err != nil {
+		return err
+	}
+
+	e := removeMemberFromDomainEvent{
+		operationPrefix: rmes.operationPrefix,
+		domainID:        domainID,
+		memberID:        memberID,
+		requestID:       middleware.GetReqID(ctx),
+	}
+	if err := rmes.Publish(ctx, rmes.streamID, e); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (rmes *RoleManagerEventStore) RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, members []string) error {
 	if err := rmes.svc.RemoveEntityMembers(ctx, session, entityID, members); err != nil {
 		return err

pkg/roles/rolemanager/middleware/authorization.go

@@ -279,6 +279,10 @@ func (ram RoleManagerAuthorizationMiddleware) RemoveEntityMembers(ctx context.Co
 	return ram.svc.RemoveEntityMembers(ctx, session, entityID, members)
 }
 
+func (ram RoleManagerAuthorizationMiddleware) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	return ram.svc.RemoveMemberFromDomain(ctx, domainID, memberID)
+}
+
 func (ram RoleManagerAuthorizationMiddleware) RoleRemoveMembers(ctx context.Context, session authn.Session, entityID, roleID string, members []string) (err error) {
 	if err := ram.authorize(ctx, session, roles.OpRoleRemoveMembers, smqauthz.PolicyReq{
 		Domain:      session.DomainID,

pkg/roles/rolemanager/middleware/callout.go

@@ -244,6 +244,10 @@ func (rcm *RoleManagerCalloutMiddleware) RoleRemoveMembers(ctx context.Context,
 	return rcm.svc.RoleRemoveMembers(ctx, session, entityID, roleID, members)
 }
 
+func (rcm *RoleManagerCalloutMiddleware) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	return rcm.svc.RemoveMemberFromDomain(ctx, domainID, memberID)
+}
+
 func (rcm *RoleManagerCalloutMiddleware) RemoveMemberFromAllRoles(ctx context.Context, session authn.Session, memberID string) error {
 	return rcm.svc.RemoveMemberFromAllRoles(ctx, session, memberID)
 }

pkg/roles/rolemanager/middleware/logging.go

@@ -368,6 +368,10 @@ func (lm *RoleManagerLoggingMiddleware) RemoveEntityMembers(ctx context.Context,
 	return lm.svc.RemoveEntityMembers(ctx, session, entityID, members)
 }
 
+func (lm *RoleManagerLoggingMiddleware) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	return lm.svc.RemoveMemberFromDomain(ctx, domainID, memberID)
+}
+
 func (lm *RoleManagerLoggingMiddleware) RemoveMemberFromAllRoles(ctx context.Context, session authn.Session, memberID string) (err error) {
 	prefix := fmt.Sprintf("%s remove members from all roles", lm.svcName)
 	defer func(begin time.Time) {

pkg/roles/rolemanager/middleware/meterics.go

@@ -100,6 +100,10 @@ func (rmm *RoleManagerMetricsMiddleware) ListEntityMembers(ctx context.Context,
 	return rmm.svc.ListEntityMembers(ctx, session, entityID, pageQuery)
 }
 
+func (rmm *RoleManagerMetricsMiddleware) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	return rmm.svc.RemoveMemberFromDomain(ctx, domainID, memberID)
+}
+
 func (rmm *RoleManagerMetricsMiddleware) RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, members []string) error {
 	return rmm.svc.RemoveEntityMembers(ctx, session, entityID, members)
 }

pkg/roles/rolemanager/middleware/tracing.go

@@ -92,6 +92,10 @@ func (rtm *RoleManagerTracing) ListEntityMembers(ctx context.Context, session au
 	return rtm.roles.ListEntityMembers(ctx, session, entityID, pageQuery)
 }
 
+func (rtm *RoleManagerTracing) RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error {
+	return rtm.roles.RemoveMemberFromDomain(ctx, domainID, memberID)
+}
+
 func (rtm *RoleManagerTracing) RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, members []string) error {
 	return rtm.roles.RemoveEntityMembers(ctx, session, entityID, members)
 }

pkg/roles/roles.go

@@ -159,6 +159,8 @@ type RoleManager interface {
 
 	RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, members []string) (err error)
 
+	RemoveMemberFromDomain(ctx context.Context, domainID, memberID string) error
+
 	RemoveMemberFromAllRoles(ctx context.Context, session authn.Session, memberID string) (err error)
 }
 
@@ -181,7 +183,10 @@ type Repository interface {
 	RoleRemoveAllMembers(ctx context.Context, role Role) (err error)
 	RetrieveEntitiesRolesActionsMembers(ctx context.Context, entityIDs []string) ([]EntityActionRole, []EntityMemberRole, error)
 	ListEntityMembers(ctx context.Context, entityID string, pageQuery MembersRolePageQuery) (MembersRolePage, error)
+	RetrieveRoleByEntityMember(ctx context.Context, entityID, memberID string) (string, error)
 	RemoveEntityMembers(ctx context.Context, entityID string, members []string) error
+	RetrieveRoleByDomainMember(ctx context.Context, domainID, memberID string) (string, error)
+	RemoveMemberFromDomain(ctx context.Context, domainID string, memberID string) error
 	RemoveMemberFromAllRoles(ctx context.Context, memberID string) (err error)
 }