Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
5.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

package adminapi

import (
	"context"
	_ "embed"
	"encoding/json"
	"fmt"
	"slices"
	"strconv"
	"strings"

	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"
)

//go:embed configschema.json
var configSchemaJSON []byte

type ConfigKey struct {
	Key       string   `json:"key"`
	Type      string   `json:"type"`
	Value     any      `json:"value"`
	Default   any      `json:"default,omitempty"`
	Help      string   `json:"help"`
	Options   []string `json:"options,omitempty"`
	SecretSet string   `json:"-"`
	Nullable  bool     `json:"-"`
}

func ConfigSchema() ([]ConfigKey, error) {
	var raw []struct {
		Key       string   `json:"key"`
		Type      string   `json:"type"`
		Help      string   `json:"help"`
		Default   any      `json:"default"`
		Options   []string `json:"options"`
		SecretSet string   `json:"secret_set"`
		Nullable  bool     `json:"nullable"`
	}
	if err := json.Unmarshal(configSchemaJSON, &raw); err != nil {
		return nil, fmt.Errorf("adminapi: config schema: %w", err)
	}
	keys := make([]ConfigKey, len(raw))
	for i, r := range raw {
		keys[i] = ConfigKey{Key: r.Key, Type: r.Type, Help: r.Help, Default: r.Default, Options: r.Options, SecretSet: r.SecretSet, Nullable: r.Nullable}
		switch r.Key {
		case RegistrationModeKey:
			keys[i].Options = RegistrationModes
			keys[i].Help = "Who can create an account. It works like rexctl registration set"
		case registrationLinksKey:
			keys[i].Help = "Whether invite links from admins still create accounts. rexctl registration set changes it for you"
		}
	}
	return keys, nil
}

const (
	RegistrationModeKey  = "registration.mode"
	registrationLinksKey = "registration.admin_registration_urls_enabled"
)

type UnknownKeyError struct {
	Key     string
	Similar []string
}

func (e *UnknownKeyError) Error() string { return fmt.Sprintf("adminapi: no setting %q", e.Key) }

func FindConfigKey(keys []ConfigKey, name string) (ConfigKey, error) {
	name = strings.TrimSpace(name)
	for _, k := range keys {
		if k.Key == name {
			return k, nil
		}
	}
	e := &UnknownKeyError{Key: name}
	last := name[strings.LastIndex(name, ".")+1:]
	for _, k := range keys {
		if last != "" && (strings.HasSuffix(k.Key, "."+last) || strings.Contains(k.Key, name)) {
			e.Similar = append(e.Similar, k.Key)
		}
	}
	return ConfigKey{}, e
}

func lookup(m map[string]any, path string) (any, bool) {
	var cur any = m
	for _, p := range strings.Split(path, ".") {
		obj, ok := cur.(map[string]any)
		if !ok {
			return nil, false
		}
		cur, ok = obj[p]
		if !ok {
			return nil, false
		}
	}
	return cur, true
}

func FillValues(keys []ConfigKey, cfg map[string]any) []ConfigKey {
	out := make([]ConfigKey, len(keys))
	for i, k := range keys {
		if k.Type == "secret" {
			v, _ := lookup(cfg, k.SecretSet)
			set, _ := v.(bool)
			k.Value = set
		} else if v, ok := lookup(cfg, k.Key); ok {
			k.Value = v
		}
		if links, _ := lookup(cfg, registrationLinksKey); k.Key == RegistrationModeKey && k.Value == "closed" && links == true {
			k.Value = "invite"
		}
		out[i] = k
	}
	return out
}

func (c *Client) ConfigValues(ctx context.Context) ([]ConfigKey, error) {
	keys, err := ConfigSchema()
	if err != nil {
		return nil, err
	}
	cfg, err := c.RawConfig(ctx)
	if err != nil {
		return nil, err
	}
	return FillValues(keys, cfg), nil
}

type InvalidValueError struct {
	Key  ConfigKey
	Want string
}

func (e *InvalidValueError) Error() string {
	return fmt.Sprintf("adminapi: %s needs %s", e.Key.Key, e.Want)
}

func ParseConfigValue(k ConfigKey, value string) (any, error) {
	switch k.Type {
	case "integer":
		n, err := strconv.ParseInt(strings.TrimSpace(value), 10, 64)
		if err != nil {
			return nil, &InvalidValueError{Key: k, Want: "a whole number"}
		}
		return n, nil
	case "number":
		f, err := strconv.ParseFloat(strings.TrimSpace(value), 64)
		if err != nil {
			return nil, &InvalidValueError{Key: k, Want: "a number"}
		}
		return f, nil
	case "boolean":
		switch strings.ToLower(strings.TrimSpace(value)) {
		case "true", "on", "yes", "1":
			return true, nil
		case "false", "off", "no", "0":
			return false, nil
		}
		return nil, &InvalidValueError{Key: k, Want: "true or false"}
	case "list":
		items := []string{}
		for _, part := range strings.Split(value, ",") {
			if part = strings.TrimSpace(part); part != "" {
				items = append(items, part)
			}
		}
		return items, nil
	case "json":
		var v any
		if err := json.Unmarshal([]byte(value), &v); err != nil {
			return nil, &InvalidValueError{Key: k, Want: "JSON"}
		}
		return v, nil
	}
	if len(k.Options) > 0 && !slices.Contains(k.Options, value) {
		return nil, &InvalidValueError{Key: k, Want: "one of " + ui.JoinOr(k.Options)}
	}
	return value, nil
}

func ConfigPatch(key string, value any) map[string]any {
	parts := strings.Split(key, ".")
	root := map[string]any{}
	cur := root
	for _, p := range parts[:len(parts)-1] {
		next := map[string]any{}
		cur[p] = next
		cur = next
	}
	cur[parts[len(parts)-1]] = value
	return root
}

func MergePatch(dst, src map[string]any) {
	for k, v := range src {
		sub, ok := v.(map[string]any)
		if have, exists := dst[k].(map[string]any); ok && exists {
			MergePatch(have, sub)
			continue
		}
		dst[k] = v
	}
}

func FormatValue(k ConfigKey) string {
	if k.Type == "secret" {
		if set, _ := k.Value.(bool); set {
			return "set"
		}
		return "not set"
	}
	switch v := k.Value.(type) {
	case nil:
		return ""
	case string:
		return v
	case bool:
		return strconv.FormatBool(v)
	case float64:
		return strconv.FormatFloat(v, 'f', -1, 64)
	case []string:
		return strings.Join(v, ", ")
	case []any:
		if all := scalarList(v); all != nil {
			return strings.Join(all, ", ")
		}
	}
	data, err := json.Marshal(k.Value)
	if err != nil {
		return fmt.Sprint(k.Value)
	}
	return string(data)
}

func scalarList(v []any) []string {
	out := make([]string, 0, len(v))
	for _, item := range v {
		s, ok := item.(string)
		if !ok {
			return nil
		}
		out = append(out, s)
	}
	return out
}