models.go

package doppler

import (
	"encoding/json"
	"errors"
	"sort"
	"strings"
)

type ComputedSecret struct {
	Name  string
	Value string
}

func ParseComputedSecrets(response []byte) ([]ComputedSecret, error) {
	var result map[string]string
	err := json.Unmarshal(response, &result)
	if err != nil {
		return nil, err
	}

	secrets := make([]ComputedSecret, 0)
	for key, value := range result {
		secret := ComputedSecret{Name: key, Value: value}
		secrets = append(secrets, secret)
	}
	sort.Slice(secrets, func(i, j int) bool {
		return secrets[i].Name < secrets[j].Name
	})
	return secrets, nil
}

type Secret struct {
	Name  string      `json:"name"`
	Value SecretValue `json:"value"`
}

type SecretValue struct {
	Raw                *string    `json:"raw,omitempty"`
	Computed           *string    `json:"computed,omitempty"`
	RawVisibility      *string    `json:"rawVisibility,omitempty"`
	ComputedVisibility *string    `json:"computedVisibility,omitempty"`
	RawValueType       *ValueType `json:"rawValueType,omitempty"`
	ComputedValueType  *ValueType `json:"computedValueType,omitempty"`
}

func getSecretsId(project string, config string) string {
	return strings.Join([]string{project, config}, ".")
}

func getSecretId(project string, config string, name string) string {
	return strings.Join([]string{project, config, name}, ".")
}

func parseSecretId(id string) (project string, config string, name string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 3 {
		return "", "", "", errors.New("invalid secret ID")
	}
	return tokens[0], tokens[1], tokens[2], nil
}

type ChangeRequest struct {
	OriginalName       *string    `json:"originalName,omitempty"`
	OriginalValue      *string    `json:"originalValue,omitempty"`
	OriginalVisibility *string    `json:"originalVisibility,omitempty"`
	Name               string     `json:"name"`
	Value              *string    `json:"value"`
	ShouldDelete       bool       `json:"shouldDelete"`
	Visibility         string     `json:"visibility,omitempty"`
	ValueType          *ValueType `json:"valueType,omitempty"`
}

type ValueType struct {
	Type string `json:"type"`
}

type Project struct {
	Slug        string `json:"slug"`
	Name        string `json:"name"`
	Description string `json:"description"`
	CreatedAt   string `json:"created_at"`
}

type ProjectResponse struct {
	Project Project `json:"project"`
}

type ProjectMemberRole struct {
	Identifier string `json:"identifier"`
}

type ProjectMember struct {
	Type                  string            `json:"type"`
	Slug                  string            `json:"slug"`
	Role                  ProjectMemberRole `json:"role"`
	AccessAllEnvironments bool              `json:"access_all_environment"`
	Environments          []string          `json:"environments,omitempty"`
}

type ProjectMemberResponse struct {
	Member ProjectMember `json:"member"`
}

func getProjectMemberId(project string, memberType string, memberSlug string) string {
	return strings.Join([]string{project, memberType, memberSlug}, ".")
}

func parseProjectMemberId(id string) (project string, memberType string, memberSlug string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 3 {
		return "", "", "", errors.New("invalid project member ID")
	}
	return tokens[0], tokens[1], tokens[2], nil
}

type IntegrationMemberRole struct {
	Identifier string `json:"identifier"`
}

type IntegrationMember struct {
	Type string                `json:"type"`
	Slug string                `json:"slug"`
	Role IntegrationMemberRole `json:"role"`
}

type IntegrationMemberResponse struct {
	Member IntegrationMember `json:"member"`
}

func getIntegrationMemberId(integration string, memberType string, memberSlug string) string {
	return strings.Join([]string{integration, memberType, memberSlug}, ".")
}

func parseIntegrationMemberId(id string) (integration string, memberType string, memberSlug string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 3 {
		return "", "", "", errors.New("invalid integration member ID")
	}
	return tokens[0], tokens[1], tokens[2], nil
}

type IntegrationData = map[string]interface{}

type Integration struct {
	Slug string `json:"slug"`
	Name string `json:"name"`
	Type string `json:"type"`
}

type IntegrationResponse struct {
	Integration Integration `json:"integration"`
}

type SyncData = map[string]interface{}

type Sync struct {
	Slug        string `json:"slug"`
	Project     string `json:"project"`
	Config      string `json:"config"`
	Integration string `json:"integration"`
}

type SyncResponse struct {
	Sync Sync `json:"sync"`
}

type RotatedSecretParameters = map[string]interface{}
type RotatedSecretCredentials = []map[string]interface{}

type RotatedSecret struct {
	Slug              string      `json:"slug"`
	Project           string      `json:"project"`
	Config            string      `json:"config"`
	Integration       Integration `json:"integration"`
	RotationPeriodSec int         `json:"rotation_period_sec"`
	Name              string      `json:"name"`
}

type RotatedSecretResponse struct {
	RotatedSecret RotatedSecret `json:"rotatedSecret"`
}

type ExternalIdResponse struct {
	ExternalId string `json:"pendingExternalId"`
}

type Environment struct {
	Slug            string `json:"slug"`
	Name            string `json:"name"`
	Project         string `json:"project"`
	CreatedAt       string `json:"created_at"`
	PersonalConfigs bool   `json:"personal_configs"`
}

type EnvironmentResponse struct {
	Environment Environment `json:"environment"`
}

type EnvironmentsResponse struct {
	Environments []Environment `json:"environments"`
}

func (e Environment) getResourceId() string {
	return strings.Join([]string{e.Project, e.Slug}, ".")
}

func parseEnvironmentResourceId(id string) (project string, name string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 2 {
		return "", "", errors.New("invalid environment ID")
	}
	return tokens[0], tokens[1], nil
}

type WebhookAuth struct {
	Type     string `json:"type"`
	Token    string `json:"token"`
	Username string `json:"username"`
	Password string `json:"password"`
}

type Webhook struct {
	Slug           string   `json:"id"`
	Name           string   `json:"name"`
	Url            string   `json:"url"`
	Enabled        bool     `json:"enabled"`
	EnabledConfigs []string `json:"enabledConfigs"`
}

type WebhookResponse struct {
	Webhook Webhook `json:"webhook"`
}

type Config struct {
	Slug        string             `json:"slug"`
	Name        string             `json:"name"`
	Project     string             `json:"project"`
	Environment string             `json:"environment"`
	Locked      bool               `json:"locked"`
	Root        bool               `json:"root"`
	CreatedAt   string             `json:"created_at"`
	Inheritable bool               `json:"inheritable"`
	Inherits    []ConfigDescriptor `json:"inherits"`
}

type ConfigDescriptor struct {
	Project string `json:"project"`
	Config  string `json:"config"`
}

type ConfigResponse struct {
	Config Config `json:"config"`
}

func (c Config) getResourceId() string {
	return strings.Join([]string{c.Project, c.Environment, c.Name}, ".")
}

func parseConfigResourceId(id string) (project string, environment string, name string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 3 {
		return "", "", "", errors.New("invalid config ID")
	}
	return tokens[0], tokens[1], tokens[2], nil
}

type ServiceToken struct {
	Slug        string `json:"slug"`
	Name        string `json:"name"`
	Project     string `json:"project"`
	Environment string `json:"environment"`
	Config      string `json:"config"`
	Access      string `json:"access"`
	Key         string `json:"key"`
	CreatedAt   string `json:"created_at"`
	ExpiresAt   string `json:"expires_at,omitempty"`
}

type ServiceTokenResponse struct {
	ServiceToken ServiceToken `json:"token"`
}

type ServiceTokenListResponse struct {
	ServiceTokens []ServiceToken `json:"tokens"`
}

func (t ServiceToken) getResourceId() string {
	return strings.Join([]string{t.Project, t.Config, t.Slug}, ".")
}

func parseServiceTokenResourceId(id string) (project string, config string, slug string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 3 {
		return "", "", "", errors.New("invalid service token ID")
	}
	return tokens[0], tokens[1], tokens[2], nil
}

type ServiceAccountToken struct {
	Name      string `json:"name"`
	ExpiresAt string `json:"expires_at"`
	CreatedAt string `json:"created_at"`
	Slug      string `json:"slug"`
}

type ServiceAccountTokenResponse struct {
	ServiceAccountToken ServiceAccountToken `json:"api_token"`
	ApiKey              string              `json:"api_key"`
}

func (t ServiceAccountToken) getResourceId() string {
	return t.Slug
}

type ServiceAccountIdentityConfigOidc struct {
	DiscoveryUrl string              `json:"discovery_url"`
	ClaimsType   string              `json:"claims_type"`
	Claims       map[string][]string `json:"claims"`
}

type ServiceAccountIdentity struct {
	Slug       string          `json:"slug"`
	Name       string          `json:"name"`
	TtlSeconds int             `json:"ttl_seconds"`
	Method     string          `json:"method"`
	Config     json.RawMessage `json:"config"`
	ConfigOidc ServiceAccountIdentityConfigOidc
}

type ServiceAccountIdentityResponse struct {
	Identity ServiceAccountIdentity `json:"identity"`
}

func (response *ServiceAccountIdentityResponse) unmarshal(data []byte) error {
	if err := json.Unmarshal(data, response); err != nil {
		return err
	}
	switch response.Identity.Method {
	case "oidc":
		response.Identity.ConfigOidc = ServiceAccountIdentityConfigOidc{}
		if err := json.Unmarshal(response.Identity.Config, &response.Identity.ConfigOidc); err != nil {
			return err
		}
	default:
		return errors.New("Unknown auth method type")
	}
	return nil
}

func (id *ServiceAccountIdentity) marshal() ([]byte, error) {
	payload := map[string]interface{}{
		"name":        id.Name,
		"ttl_seconds": id.TtlSeconds,
		"method":      id.Method,
	}
	switch id.Method {
	case "oidc":
		payload["config"] = map[string]interface{}{
			"discovery_url": id.ConfigOidc.DiscoveryUrl,
			"claims_type":   id.ConfigOidc.ClaimsType,
			"claims":        id.ConfigOidc.Claims,
		}
	default:
		return nil, errors.New("Unknown auth method type")
	}
	return json.Marshal(payload)
}

type WorkplaceRole struct {
	Name         string   `json:"name"`
	Permissions  []string `json:"permissions"`
	Identifier   string   `json:"identifier,omitempty"`
	IsCustomRole bool     `json:"is_custom_role"`
	IsInlineRole bool     `json:"is_inline_role"`
	CreatedAt    string   `json:"created_at"`
}

type ServiceAccount struct {
	Slug          string        `json:"slug"`
	Name          string        `json:"name"`
	CreatedAt     string        `json:"created_at"`
	WorkplaceRole WorkplaceRole `json:"workplace_role"`
}

type ServiceAccountResponse struct {
	ServiceAccount ServiceAccount `json:"service_account"`
}

type SimpleProjectRole struct {
	Identifier string `json:"identifier"`
}

type SimpleWorkplaceRole struct {
	Identifier string `json:"identifier"`
}

type ProjectRole struct {
	Identifier   string   `json:"identifier"`
	Name         string   `json:"name"`
	Permissions  []string `json:"permissions"`
	CreatedAt    string   `json:"created_at"`
	IsCustomRole bool     `json:"is_custom_role"`
}

type GetProjectRoleResponse struct {
	Role ProjectRole `json:"role"`
}

type CreateProjectRoleResponse struct {
	Role ProjectRole `json:"role"`
}

type UpdateProjectRoleResponse struct {
	Role ProjectRole `json:"role"`
}

type Group struct {
	Slug               string              `json:"slug"`
	Name               string              `json:"name"`
	CreatedAt          string              `json:"created_at"`
	DefaultProjectRole SimpleProjectRole   `json:"default_project_role"`
	WorkplaceRole      SimpleWorkplaceRole `json:"workplace_role"`
}

type GroupResponse struct {
	Group Group `json:"group"`
}

type GroupsResponse struct {
	Groups []Group `json:"groups"`
}

type GroupIsMemberResponse struct {
	IsMember bool `json:"isMember"`
}

type GroupMember struct {
	Type string `json:"type"`
	Slug string `json:"slug"`
}

type GetGroupMembersResponse struct {
	Members []GroupMember `json:"members"`
}

type WorkplaceUser struct {
	Slug string `json:"id"`
}

type WorkplaceUsersListResponse struct {
	WorkplaceUsers []WorkplaceUser `json:"workplace_users"`
}

func getGroupMemberId(group string, memberType string, memberSlug string) string {
	return strings.Join([]string{group, memberType, memberSlug}, ".")
}

func parseGroupMemberId(id string) (group string, memberType string, memberSlug string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 3 {
		return "", "", "", errors.New("invalid group member ID")
	}
	return tokens[0], tokens[1], tokens[2], nil
}

type ChangeRequestPolicySubject struct {
	Type string `json:"type"`
	Slug string `json:"slug"`
}

type ChangeRequestPolicyRule struct {
	Type     string                       `json:"type"`
	Count    int                          `json:"count,omitempty"`
	Subjects []ChangeRequestPolicySubject `json:"subjects,omitempty"`
	Strategy string                       `json:"strategy,omitempty"`
}

type ChangeRequestPolicyTargetProject struct {
	All         bool     `json:"all"`
	EnvSlugs    []string `json:"envSlugs,omitempty"`
	ConfigNames []string `json:"configNames,omitempty"`
}

type ChangeRequestPolicyTargets struct {
	AllProjects bool                                        `json:"allProjects"`
	Projects    map[string]ChangeRequestPolicyTargetProject `json:"projects"`
}

type ChangeRequestPolicy struct {
	Slug        string                     `json:"id"`
	Name        string                     `json:"name"`
	Description string                     `json:"description"`
	Rules       []ChangeRequestPolicyRule  `json:"rules"`
	Targets     ChangeRequestPolicyTargets `json:"targets"`
}

type ChangeRequestPolicyResponse struct {
	Policy ChangeRequestPolicy `json:"policy"`
}

var NameTransformers = []string{"none", "camel", "upper-camel", "lower-snake", "tf-var", "dotnet", "dotnet-env", "lower-kebab"}

type GetWorkplaceRoleResponse struct {
	Role WorkplaceRole `json:"role"`
}

type CreateWorkplaceRoleResponse struct {
	Role WorkplaceRole `json:"role"`
}

type UpdateWorkplaceRoleResponse struct {
	Role WorkplaceRole `json:"role"`
}

type TrustedIPsResponse struct {
	IPs []string `json:"ips"`
}

func getTrustedIPsResourceId(project, config string) string {
	return strings.Join([]string{project, config}, ".")
}

func parseTrustedIPsResourceId(id string) (project string, config string, err error) {
	tokens := strings.Split(id, ".")
	if len(tokens) != 2 {
		return "", "", errors.New("invalid trusted IPs resource ID")
	}
	return tokens[0], tokens[1], nil
}