enh: move core structs to app

pkg/app/app.go

@@ -7,6 +7,7 @@ import (
 	"github.com/sourcegraph/conc/iter"
 
 	"github.com/notdodo/goflat"
+	oktaSdk "github.com/okta/okta-sdk-golang/v2/okta"
 )
 
 type IAMme interface {
@@ -30,7 +31,7 @@ type iamme struct {
 
 func (a *iamme) Dump() {
 	a.createNodes([]string{"User"}, flat(a.getUsers()))
-	groups := a.getGroups()
+	groups := a.getGroupsWithMembers()
 	a.createNodes([]string{"Group"}, flat(groups))
 	rules := a.getRules()
 	a.createNodes([]string{"Rule"}, flat(rules))
@@ -62,40 +63,59 @@ func (a *iamme) Dump() {
 	a.createRelations("GroupMember", []string{"User"}, []string{"Group"}, groupMembers)
 }
 
-func (a *iamme) getUsers() []*okta.User {
-	users, err := a.oktaClient.GetUsers()
+func (a *iamme) getUsers() []*User {
+	oktaUsers, err := a.oktaClient.GetUsers()
+	users := make([]*User, 0, len(oktaUsers))
 	if err != nil {
 		a.logger.Error("Error fetching users from Okta:", "err", err)
 	}
+
+	for _, user := range oktaUsers {
+		users = append(users, &User{
+			User: user,
+		})
+	}
 	return users
 }
 
-func (a *iamme) getGroups() []*okta.Group {
-	groups, err := a.oktaClient.GetGroups()
+func (a *iamme) getGroupsWithMembers() []*Group {
+	oktaGroups, err := a.oktaClient.GetGroups()
 	if err != nil {
 		a.logger.Error("Error fetching groups from Okta:", "err", err)
 		return nil
 	}
-	groupsWithMembers := iter.Map(groups, func(group **okta.Group) *okta.Group {
+	groupsWithMembers := iter.Map(oktaGroups, func(group **oktaSdk.Group) *Group {
 		members, err := a.oktaClient.GetGroupMembers((*group).Id)
 		if err != nil {
 			a.logger.Error("Error fetching group members from Okta:", "err", err)
 		}
-		elem := &okta.Group{
-			Group:   (*group).Group,
-			Members: members,
+		users := make([]*User, 0, len(members))
+		for _, member := range members {
+			users = append(users, &User{
+				User: member,
+			})
+		}
+		return &Group{
+			Group:   *group,
+			Members: users,
 		}
-		return elem
 	})
 
 	return groupsWithMembers
 }
 
-func (a *iamme) getRules() []*okta.GroupRule {
-	rules, err := a.oktaClient.GetGroupsRules()
+func (a *iamme) getRules() []*GroupRule {
+	oktaRules, err := a.oktaClient.GetGroupsRules()
+	rules := make([]*GroupRule, 0, len(oktaRules))
 	if err != nil {
 		a.logger.Error("Error fetching rules from Okta:", "err", err)
 	}
+
+	for _, rule := range oktaRules {
+		rules = append(rules, &GroupRule{
+			GroupRule: rule,
+		})
+	}
 	return rules
 }
 

pkg/app/structs.go

@@ -0,0 +1,16 @@
+package app
+
+import "github.com/okta/okta-sdk-golang/v2/okta"
+
+type Group struct {
+	*okta.Group
+	Members []*User
+}
+
+type User struct {
+	*okta.User
+}
+
+type GroupRule struct {
+	*okta.GroupRule
+}

pkg/infra/okta/okta_client.go

@@ -11,30 +11,17 @@ import (
 
 // OktaClient is an interface for interacting with Okta resources.
 type OktaClient interface {
-	GetUsers() ([]*User, error)
-	GetGroups() ([]*Group, error)
-	GetGroupsRules() ([]*GroupRule, error)
-	GetGroupMembers(string) ([]*User, error)
+	GetUsers() ([]*okta.User, error)
+	GetGroups() ([]*okta.Group, error)
+	GetGroupsRules() ([]*okta.GroupRule, error)
+	GetGroupMembers(string) ([]*okta.User, error)
 }
 
 type oktaClient struct {
 	oktaClient *okta.Client
 	log        logging.LogManager
 }
 
-type Group struct {
-	*okta.Group
-	Members []*User
-}
-
-type User struct {
-	*okta.User
-}
-
-type GroupRule struct {
-	*okta.GroupRule
-}
-
 func NewOktaClient(orgUrl, apiKey string) OktaClient {
 	logger := logging.GetLogManager()
 	_, client, err := okta.NewClient(context.TODO(), okta.WithOrgUrl(fmt.Sprintf("https://%s", orgUrl)), okta.WithToken(apiKey))
@@ -48,14 +35,12 @@ func NewOktaClient(orgUrl, apiKey string) OktaClient {
 	}
 }
 
-func (c *oktaClient) GetUsers() ([]*User, error) {
+func (c *oktaClient) GetUsers() ([]*okta.User, error) {
 	c.log.Info("Getting Okta users")
-	var users []*User
+	var users []*okta.User
 	appendUsers := func(oktaUsers []*okta.User) {
 		for _, oktaUser := range oktaUsers {
-			users = append(users, &User{
-				User: oktaUser,
-			})
+			users = append(users, oktaUser)
 		}
 	}
 
@@ -77,56 +62,39 @@ func (c *oktaClient) GetUsers() ([]*User, error) {
 	return users, nil
 }
 
-func (c *oktaClient) GetGroups() ([]*Group, error) {
+func (c *oktaClient) GetGroups() ([]*okta.Group, error) {
 	c.log.Info("Getting Okta groups")
 	oktaGroups, response, err := c.oktaClient.Group.ListGroups(context.TODO(), &query.Params{
 		Expand: "stats,app",
 	})
 	if err != nil {
 		return nil, err
 	}
-	groups := make([]*Group, 0, len(oktaGroups))
-	for _, oktaGroup := range oktaGroups {
-		groups = append(groups, &Group{
-			Group: oktaGroup,
-		})
-	}
 
-	c.log.Info(fmt.Sprintf("Found %d groups", len(groups)))
-	c.log.Debug(fmt.Sprintf("Found %d groups", len(groups)), "groups", response.Body)
-	return groups, nil
+	c.log.Info(fmt.Sprintf("Found %d groups", len(oktaGroups)))
+	c.log.Debug(fmt.Sprintf("Found %d groups", len(oktaGroups)), "groups", response.Body)
+	return oktaGroups, nil
 }
 
-func (c *oktaClient) GetGroupsRules() ([]*GroupRule, error) {
+func (c *oktaClient) GetGroupsRules() ([]*okta.GroupRule, error) {
 	c.log.Info("Getting Okta groups rules")
 	oktaRules, response, err := c.oktaClient.Group.ListGroupRules(context.TODO(), nil)
 	if err != nil {
 		return nil, err
 	}
-	rules := make([]*GroupRule, 0, len(oktaRules))
-	for _, oktaRule := range oktaRules {
-		rules = append(rules, &GroupRule{
-			GroupRule: oktaRule,
-		})
-	}
-	c.log.Info(fmt.Sprintf("Found %d rules", len(rules)))
-	c.log.Debug(fmt.Sprintf("Found %d rules", len(rules)), "rules", response.Body)
-	return rules, nil
+
+	c.log.Info(fmt.Sprintf("Found %d rules", len(oktaRules)))
+	c.log.Debug(fmt.Sprintf("Found %d rules", len(oktaRules)), "rules", response.Body)
+	return oktaRules, nil
 }
 
-func (c *oktaClient) GetGroupMembers(groupId string) ([]*User, error) {
+func (c *oktaClient) GetGroupMembers(groupId string) ([]*okta.User, error) {
 	c.log.Info("Getting Okta group members", "group", groupId)
 	oktaMembers, response, err := c.oktaClient.Group.ListGroupUsers(context.TODO(), groupId, nil)
 	if err != nil {
 		return nil, err
 	}
-	members := make([]*User, 0, len(oktaMembers))
-	for _, member := range oktaMembers {
-		members = append(members, &User{
-			User: member,
-		})
-	}
-	c.log.Info(fmt.Sprintf("Found %d members for group %s", len(members), groupId))
-	c.log.Debug(fmt.Sprintf("Found %d members for group %s", len(members), groupId), "members", response.Body)
-	return members, err
+	c.log.Info(fmt.Sprintf("Found %d members for group %s", len(oktaMembers), groupId))
+	c.log.Debug(fmt.Sprintf("Found %d members for group %s", len(oktaMembers), groupId), "members", response.Body)
+	return oktaMembers, err
 }