core/server: refactory to use shared params/request structs

core/internal/server/params/params.go

@@ -0,0 +1,113 @@
+package params
+
+import "fmt"
+
+func Get[T any](params map[string]any, key string) (T, error) {
+	val, ok := params[key].(T)
+	if !ok {
+		var zero T
+		return zero, fmt.Errorf("missing or invalid '%s' parameter", key)
+	}
+	return val, nil
+}
+
+func GetOpt[T any](params map[string]any, key string, def T) T {
+	if val, ok := params[key].(T); ok {
+		return val
+	}
+	return def
+}
+
+func String(params map[string]any, key string) (string, error) {
+	return Get[string](params, key)
+}
+
+func StringNonEmpty(params map[string]any, key string) (string, error) {
+	val, err := Get[string](params, key)
+	if err != nil || val == "" {
+		return "", fmt.Errorf("missing or invalid '%s' parameter", key)
+	}
+	return val, nil
+}
+
+func StringOpt(params map[string]any, key string, def string) string {
+	return GetOpt(params, key, def)
+}
+
+func Int(params map[string]any, key string) (int, error) {
+	val, err := Get[float64](params, key)
+	if err != nil {
+		return 0, err
+	}
+	return int(val), nil
+}
+
+func IntOpt(params map[string]any, key string, def int) int {
+	if val, ok := params[key].(float64); ok {
+		return int(val)
+	}
+	return def
+}
+
+func Float(params map[string]any, key string) (float64, error) {
+	return Get[float64](params, key)
+}
+
+func FloatOpt(params map[string]any, key string, def float64) float64 {
+	return GetOpt(params, key, def)
+}
+
+func Bool(params map[string]any, key string) (bool, error) {
+	return Get[bool](params, key)
+}
+
+func BoolOpt(params map[string]any, key string, def bool) bool {
+	return GetOpt(params, key, def)
+}
+
+func StringMap(params map[string]any, key string) (map[string]string, error) {
+	rawMap, err := Get[map[string]any](params, key)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string]string)
+	for k, v := range rawMap {
+		if str, ok := v.(string); ok {
+			result[k] = str
+		}
+	}
+	return result, nil
+}
+
+func StringMapOpt(params map[string]any, key string) map[string]string {
+	rawMap, ok := params[key].(map[string]any)
+	if !ok {
+		return nil
+	}
+	result := make(map[string]string)
+	for k, v := range rawMap {
+		if str, ok := v.(string); ok {
+			result[k] = str
+		}
+	}
+	return result
+}
+
+func Any(params map[string]any, key string) (any, bool) {
+	val, ok := params[key]
+	return val, ok
+}
+
+func AnyMap(params map[string]any, key string) (map[string]any, bool) {
+	val, ok := params[key].(map[string]any)
+	return val, ok
+}
+
+func StringAlt(params map[string]any, keys ...string) (string, bool) {
+	for _, key := range keys {
+		if val, ok := params[key].(string); ok {
+			return val, true
+		}
+	}
+	return "", false
+}

core/internal/server/params/params_test.go

@@ -0,0 +1,154 @@
+package params
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGet(t *testing.T) {
+	p := map[string]any{"key": "value"}
+	val, err := Get[string](p, "key")
+	assert.NoError(t, err)
+	assert.Equal(t, "value", val)
+
+	_, err = Get[string](p, "missing")
+	assert.Error(t, err)
+
+	_, err = Get[int](p, "key")
+	assert.Error(t, err)
+}
+
+func TestGetOpt(t *testing.T) {
+	p := map[string]any{"key": "value"}
+	assert.Equal(t, "value", GetOpt(p, "key", "default"))
+	assert.Equal(t, "default", GetOpt(p, "missing", "default"))
+}
+
+func TestString(t *testing.T) {
+	p := map[string]any{"s": "hello", "n": 123}
+	val, err := String(p, "s")
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", val)
+
+	_, err = String(p, "n")
+	assert.Error(t, err)
+}
+
+func TestStringNonEmpty(t *testing.T) {
+	p := map[string]any{"s": "hello", "empty": ""}
+	val, err := StringNonEmpty(p, "s")
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", val)
+
+	_, err = StringNonEmpty(p, "empty")
+	assert.Error(t, err)
+
+	_, err = StringNonEmpty(p, "missing")
+	assert.Error(t, err)
+}
+
+func TestStringOpt(t *testing.T) {
+	p := map[string]any{"s": "hello"}
+	assert.Equal(t, "hello", StringOpt(p, "s", "default"))
+	assert.Equal(t, "default", StringOpt(p, "missing", "default"))
+}
+
+func TestInt(t *testing.T) {
+	p := map[string]any{"n": float64(42), "s": "str"}
+	val, err := Int(p, "n")
+	assert.NoError(t, err)
+	assert.Equal(t, 42, val)
+
+	_, err = Int(p, "s")
+	assert.Error(t, err)
+}
+
+func TestIntOpt(t *testing.T) {
+	p := map[string]any{"n": float64(42)}
+	assert.Equal(t, 42, IntOpt(p, "n", 0))
+	assert.Equal(t, 99, IntOpt(p, "missing", 99))
+}
+
+func TestFloat(t *testing.T) {
+	p := map[string]any{"f": 3.14, "s": "str"}
+	val, err := Float(p, "f")
+	assert.NoError(t, err)
+	assert.Equal(t, 3.14, val)
+
+	_, err = Float(p, "s")
+	assert.Error(t, err)
+}
+
+func TestFloatOpt(t *testing.T) {
+	p := map[string]any{"f": 3.14}
+	assert.Equal(t, 3.14, FloatOpt(p, "f", 0))
+	assert.Equal(t, 1.0, FloatOpt(p, "missing", 1.0))
+}
+
+func TestBool(t *testing.T) {
+	p := map[string]any{"b": true, "s": "str"}
+	val, err := Bool(p, "b")
+	assert.NoError(t, err)
+	assert.True(t, val)
+
+	_, err = Bool(p, "s")
+	assert.Error(t, err)
+}
+
+func TestBoolOpt(t *testing.T) {
+	p := map[string]any{"b": true}
+	assert.True(t, BoolOpt(p, "b", false))
+	assert.True(t, BoolOpt(p, "missing", true))
+}
+
+func TestStringMap(t *testing.T) {
+	p := map[string]any{
+		"m": map[string]any{"a": "1", "b": "2", "c": 3},
+	}
+	val, err := StringMap(p, "m")
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]string{"a": "1", "b": "2"}, val)
+
+	_, err = StringMap(p, "missing")
+	assert.Error(t, err)
+}
+
+func TestStringMapOpt(t *testing.T) {
+	p := map[string]any{
+		"m": map[string]any{"a": "1"},
+	}
+	assert.Equal(t, map[string]string{"a": "1"}, StringMapOpt(p, "m"))
+	assert.Nil(t, StringMapOpt(p, "missing"))
+}
+
+func TestAny(t *testing.T) {
+	p := map[string]any{"k": 123}
+	val, ok := Any(p, "k")
+	assert.True(t, ok)
+	assert.Equal(t, 123, val)
+
+	_, ok = Any(p, "missing")
+	assert.False(t, ok)
+}
+
+func TestAnyMap(t *testing.T) {
+	inner := map[string]any{"nested": true}
+	p := map[string]any{"m": inner}
+	val, ok := AnyMap(p, "m")
+	assert.True(t, ok)
+	assert.Equal(t, inner, val)
+
+	_, ok = AnyMap(p, "missing")
+	assert.False(t, ok)
+}
+
+func TestStringAlt(t *testing.T) {
+	p := map[string]any{"b": "found"}
+	val, ok := StringAlt(p, "a", "b", "c")
+	assert.True(t, ok)
+	assert.Equal(t, "found", val)
+
+	_, ok = StringAlt(p, "x", "y")
+	assert.False(t, ok)
+}