api: implement namer

Closes TNTP-4190

Author: patapenka-alexey

hasher/hasher_test.go

@@ -61,9 +61,9 @@ func TestSHA256Hasher(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		name string
-		in   []byte
-		out  string
+		name     string
+		in       []byte
+		expected string
 	}{
 		{"empty", []byte(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
 		{"abc", []byte("abc"), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
@@ -77,7 +77,7 @@ func TestSHA256Hasher(t *testing.T) {
 
 			result, _ := h.Hash(test.in)
 
-			assert.Equal(t, test.out, hex.EncodeToString(result))
+			assert.Equal(t, test.expected, hex.EncodeToString(result))
 		})
 	}
 }

kv/kv.go

@@ -9,7 +9,6 @@ type KeyValue struct {
 	Key []byte
 	// Value is the serialized representation of the value.
 	Value []byte
-
 	// ModRevision is the revision number of the last modification to this key.
 	ModRevision int64
 }

marshaller/marshaller.go

@@ -17,24 +17,24 @@ var ErrUnmarshall = errors.New("failed to unmarshal")
 // implements one time for all objects.
 // Required for `integrity.Storage` to set marshalling format for any type object
 // and as recommendation for developers of `Storage` wrappers.
-type DefaultMarshaller interface {
+type DefaultMarshaller interface { //nolint:iface
 	Marshal(data any) ([]byte, error)
 	Unmarshal(data []byte, out any) error
 }
 
 // Marshallable - custom object serialization, implements for each object.
 // Required for `integrity.Storage` type to set marshalling format to specific object
 // and as recommendation for developers of `Storage` wrappers.
-type Marshallable interface {
-	Marshal() ([]byte, error)
+type Marshallable interface { //nolint:iface
+	Marshal(data any) ([]byte, error)
 	Unmarshal(data []byte, out any) error
 }
 
 // YAMLMarshaller struct represent realization.
 type YAMLMarshaller struct{}
 
 // NewYamlMarshaller creates new NewYamlMarshaller object.
-func NewYamlMarshaller() YAMLMarshaller {
+func NewYamlMarshaller() Marshallable {
 	return YAMLMarshaller{}
 }
 

namer/key.go

@@ -0,0 +1,70 @@
+package namer
+
+// KeyType represents key types.
+type KeyType int
+
+const (
+	// KeyTypeValue represents data type.
+	KeyTypeValue KeyType = iota + 1
+	// KeyTypeHash represents hash of the data type.
+	KeyTypeHash
+	// KeyTypeSignature represents signature of the data type.
+	KeyTypeSignature
+)
+
+// Key defines the minimal interface required by keys.
+type Key interface {
+	Name() string     // Get object name.
+	Type() KeyType    // Get key type.
+	Property() string // Get metadata (e.g., algorithm version).
+	Raw() []byte      // Get raw data.
+	Build() string    // Reconstruct raw key string.
+}
+
+// DefaultKey implements default realization.
+type DefaultKey struct {
+	name     string  // Object identifier.
+	keytype  KeyType // Type of object (hash/signature/value).
+	property string  // Additional metadata (version/algorithm).
+	raw      []byte  // Raw key string.
+}
+
+// NewDefaultKey returns new Key object.
+func NewDefaultKey(name string, keytype KeyType, property string, raw []byte) DefaultKey {
+	return DefaultKey{
+		name:     name,
+		keytype:  keytype,
+		property: property,
+		raw:      raw,
+	}
+}
+
+// Name returns name of the key.
+func (k DefaultKey) Name() string {
+	return k.name
+}
+
+// Type returns type of the key.
+func (k DefaultKey) Type() KeyType {
+	return k.keytype
+}
+
+// Property returns property of the key.
+func (k DefaultKey) Property() string {
+	return k.property
+}
+
+// Raw returns raw of the key.
+func (k DefaultKey) Raw() []byte {
+	return k.raw
+}
+
+// Build should reconstruct key from signature and digest or not?
+func (k DefaultKey) Build() string {
+	return string(k.raw)
+}
+
+// String returns string representation of the `raw` field.
+func (k DefaultKey) String() string {
+	return string(k.raw)
+}

namer/namer.go

@@ -2,41 +2,180 @@
 package namer
 
 import (
-	"github.com/tarantool/go-storage/kv"
+	"errors"
+	"fmt"
+	"iter"
+	"strings"
 )
 
-// KeyType represents key types.
-type KeyType int
-
 const (
-	// KeyTypeValue represents data type.
-	KeyTypeValue KeyType = iota + 1
-	// KeyTypeHash represents hash of the data type.
-	KeyTypeHash
-	// KeyTypeSignature represents signature of the data type.
-	KeyTypeSignature
+	hashName      = "hash"
+	signatureName = "sig"
+	keysPerName   = 3
+)
+
+var (
+	// ErrInvalidKey is returned when missing key, hash or signature.
+	ErrInvalidKey = errors.New("missing key, hash or signature")
+	// ErrInvalidInput is returned when input data is invalid.
+	ErrInvalidInput = errors.New("failed to generate: invalid input data")
+	// ErrInvalidPrefix is returned when prefix didn't match.
+	ErrInvalidPrefix = errors.New("invalid prefix")
 )
 
-// Key implements internal realization.
-type Key struct {
-	Name     string  // Object identificator.
-	Type     KeyType // Type of the object.
-	Property string  // Additional information (version/algorithm).
+// Results represents Namer working result.
+type Results struct {
+	IsSingle     bool             // True if result contains only one object name.
+	IsSingleName string           // Cached name when isSingle=true.
+	Result       map[string][]Key // Grouped keys: object name -> key list.
 }
 
-// Namer represents keys naming strategy.
-type Namer interface {
-	GenerateNames(name string) []string // Object's keys generation.
-	ParseNames(names []string) []Key    // Convert names into keys.
+// SelectSingle gets keys for single-name case (if applicable).
+func (r *Results) SelectSingle() ([]Key, bool) {
+	if r.IsSingle {
+		return r.Result[r.IsSingleName], true
+	}
+
+	return nil, false
+}
+
+// Items return iterator over all name->keys groups.
+func (r *Results) Items() iter.Seq2[string, []Key] {
+	return func(yield func(str string, res []Key) bool) {
+		for i, v := range r.Result {
+			if !yield(i, v) {
+				return
+			}
+		}
+	}
+}
+
+// Select gets keys for a specific object name.
+func (r *Results) Select(name string) ([]Key, bool) {
+	if i, ok := r.Result[name]; ok {
+		return i, true
+	}
+
+	return nil, false
 }
 
-// Generator generates signer K/V pairs.
-// Implementation should use `generic` and will used for strong typing of the solution.
-type Generator[T any] interface {
-	Generate(name string, value T) ([]kv.KeyValue, error)
+// Len returns the number of unique object names.
+func (r *Results) Len() int {
+	return len(r.Result)
+}
+
+// DefaultNamer represents default namer.
+type DefaultNamer struct {
+	prefix    string // Key prefix (e.g., "storage/").
+	hashNames []string
+	sigNames  []string
+}
+
+// NewDefaultNamer returns new DefaultNamer object with hash/signature names configuration.
+func NewDefaultNamer(prefix string, hashNames []string, sigNames []string) *DefaultNamer {
+	prefix = strings.TrimPrefix(prefix, "/")
+	prefix = strings.TrimSuffix(prefix, "/")
+
+	return &DefaultNamer{
+		prefix:    prefix,    // "storage/".
+		hashNames: hashNames, // "sha256".
+		sigNames:  sigNames,  // "RSAPSS".
+	}
+}
+
+// GenerateNames all keys for an object name.
+func (n *DefaultNamer) GenerateNames(name string) []Key {
+	name = strings.TrimPrefix(name, "/")
+
+	out := make([]Key, 0, len(n.hashNames)+len(n.sigNames)+1)
+
+	out = append(out,
+		NewDefaultKey(
+			fmt.Sprintf("/%s/%s", n.prefix, name),
+			KeyTypeValue,
+			"",
+			[]byte{},
+		))
+
+	for _, hash := range n.hashNames {
+		out = append(out,
+			NewDefaultKey(
+				fmt.Sprintf("/%s/%s/%s/%s", n.prefix, hashName, hash, name),
+				KeyTypeHash,
+				hash,
+				[]byte{},
+			),
+		)
+	}
+
+	for _, sig := range n.sigNames {
+		out = append(out,
+			NewDefaultKey(
+				fmt.Sprintf("/%s/%s/%s/%s", n.prefix, signatureName, sig, name),
+				KeyTypeSignature,
+				sig,
+				[]byte{},
+			),
+		)
+	}
+
+	return out
 }
 
-// Validator validates and build the object from K/V.
-type Validator[T any] interface {
-	Validate(pairs []kv.KeyValue) (T, error)
+// ParseKeys combine multiple raw keys into grouped results.
+func (n *DefaultNamer) ParseKeys(names []string) (Results, error) {
+	var out Results
+
+	out.Result = map[string][]Key{}
+
+	if len(names) == 0 {
+		return out, ErrInvalidInput
+	}
+
+	if len(names) == 1 {
+		out.IsSingle = true
+		out.IsSingleName = names[0]
+	}
+
+	for _, name := range names {
+		originName := name
+
+		name, found := strings.CutPrefix(name, n.prefix)
+		if !found {
+			return out, ErrInvalidInput
+		}
+
+		name = strings.TrimPrefix(name, "/")
+		name = strings.TrimSuffix(name, "/")
+
+		parts := strings.Split(name, "/")
+		partslen := len(parts)
+
+		var keyType KeyType
+
+		var keyProp string
+
+		switch parts[0] {
+		case hashName:
+			keyType = KeyTypeHash
+			keyProp = parts[1]
+		case signatureName:
+			keyType = KeyTypeSignature
+			keyProp = parts[1]
+		default:
+			keyType = KeyTypeValue
+			keyProp = ""
+		}
+
+		key := NewDefaultKey(
+			originName,
+			keyType,
+			keyProp,
+			[]byte{},
+		)
+
+		out.Result[parts[partslen-1]] = append(out.Result[parts[partslen-1]], key)
+	}
+
+	return out, nil
 }