probo/pkg/accessreview/drivers/posthog.go

// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

package drivers

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

	"go.probo.inc/probo/pkg/coredata"
)

type PostHogDriver struct {
	httpClient *http.Client
}

var _ Driver = (*PostHogDriver)(nil)

const (
	posthogMembersEndpoint = "https://app.posthog.com/api/organizations/@current/members/"
	posthogMembersPageSize = 100

	posthogMembershipLevelMember = 1
	posthogMembershipLevelAdmin  = 8
	posthogMembershipLevelOwner  = 15
)

type (
	posthogMembersResponse struct {
		Next    string          `json:"next"`
		Results []posthogMember `json:"results"`
	}

	posthogMember struct {
		ID           string            `json:"id"`
		User         posthogMemberUser `json:"user"`
		Level        int               `json:"level"`
		Is2FAEnabled *bool             `json:"is_2fa_enabled"`
		JoinedAt     string            `json:"joined_at"`
		LastLogin    string            `json:"last_login"`
	}

	posthogMemberUser struct {
		UUID               string `json:"uuid"`
		FirstName          string `json:"first_name"`
		LastName           string `json:"last_name"`
		Email              string `json:"email"`
		RoleAtOrganization string `json:"role_at_organization"`
	}
)

func NewPostHogDriver(httpClient *http.Client) *PostHogDriver {
	return &PostHogDriver{httpClient: httpClient}
}

func (d *PostHogDriver) ListAccounts(ctx context.Context) ([]AccountRecord, error) {
	nextURL, err := buildPostHogMembersURL()
	if err != nil {
		return nil, err
	}

	var records []AccountRecord

	for range maxPaginationPages {
		resp, err := d.fetchMembers(ctx, nextURL)
		if err != nil {
			return nil, err
		}

		for _, member := range resp.Results {
			record := posthogAccountRecord(member)
			if record.Email == "" {
				continue
			}

			records = append(records, record)
		}

		if resp.Next == "" {
			return records, nil
		}

		nextURL, err = resolvePostHogNextURL(resp.Next)
		if err != nil {
			return nil, err
		}
	}

	return nil, fmt.Errorf("cannot list all posthog accounts: %w", ErrPaginationLimitReached)
}

func buildPostHogMembersURL() (string, error) {
	u, err := url.Parse(posthogMembersEndpoint)
	if err != nil {
		return "", fmt.Errorf("cannot parse posthog members URL: %w", err)
	}

	q := u.Query()
	q.Set("limit", strconv.Itoa(posthogMembersPageSize))
	q.Set("order", "-joined_at")
	u.RawQuery = q.Encode()

	return u.String(), nil
}

func resolvePostHogNextURL(next string) (string, error) {
	nextURL, err := url.Parse(next)
	if err != nil {
		return "", fmt.Errorf("cannot parse posthog next page URL: %w", err)
	}

	if nextURL.IsAbs() {
		return nextURL.String(), nil
	}

	baseURL, err := url.Parse(posthogMembersEndpoint)
	if err != nil {
		return "", fmt.Errorf("cannot parse posthog members base URL: %w", err)
	}

	return baseURL.ResolveReference(nextURL).String(), nil
}

func (d *PostHogDriver) fetchMembers(
	ctx context.Context,
	nextURL string,
) (*posthogMembersResponse, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, nextURL, nil)
	if err != nil {
		return nil, fmt.Errorf("cannot create posthog members request: %w", err)
	}

	req.Header.Set("Accept", "application/json")

	httpResp, err := d.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("cannot execute posthog members request: %w", err)
	}

	defer func() {
		_ = httpResp.Body.Close()
	}()

	if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
		return nil, fmt.Errorf("cannot fetch posthog members: unexpected status %d", httpResp.StatusCode)
	}

	var resp posthogMembersResponse
	if err := json.NewDecoder(httpResp.Body).Decode(&resp); err != nil {
		return nil, fmt.Errorf("cannot decode posthog members response: %w", err)
	}

	return &resp, nil
}

func posthogAccountRecord(member posthogMember) AccountRecord {
	record := AccountRecord{
		Email:       member.User.Email,
		FullName:    posthogFullName(member.User),
		Role:        posthogRole(member.Level, member.User.RoleAtOrganization),
		IsAdmin:     posthogIsAdmin(member.Level),
		ExternalID:  member.User.UUID,
		MFAStatus:   posthogMFAStatus(member.Is2FAEnabled),
		AuthMethod:  coredata.AccessEntryAuthMethodUnknown,
		AccountType: coredata.AccessEntryAccountTypeUser,
	}

	if record.ExternalID == "" {
		record.ExternalID = member.ID
	}

	if t, ok := parseRFC3339(member.JoinedAt); ok {
		record.CreatedAt = &t
	}

	if t, ok := parseRFC3339(member.LastLogin); ok {
		record.LastLogin = &t
	}

	return record
}

func posthogFullName(user posthogMemberUser) string {
	return strings.TrimSpace(strings.Join([]string{user.FirstName, user.LastName}, " "))
}

func posthogRole(level int, fallback string) string {
	switch {
	case level >= posthogMembershipLevelOwner:
		return "Owner"
	case level >= posthogMembershipLevelAdmin:
		return "Admin"
	case level >= posthogMembershipLevelMember:
		return "Member"
	case fallback != "":
		return fallback
	default:
		return "Member"
	}
}

func posthogIsAdmin(level int) bool {
	return level >= posthogMembershipLevelAdmin
}

func posthogMFAStatus(twoFAEnabled *bool) coredata.MFAStatus {
	if twoFAEnabled == nil {
		return coredata.MFAStatusUnknown
	}

	if *twoFAEnabled {
		return coredata.MFAStatusEnabled
	}

	return coredata.MFAStatusDisabled
}

func parseRFC3339(value string) (time.Time, bool) {
	if value == "" {
		return time.Time{}, false
	}

	t, err := time.Parse(time.RFC3339, value)
	if err != nil {
		return time.Time{}, false
	}

	return t, true
}