api: implement namer, generator, validator

[patapenka-alexey]

Closes TNTP-4190

[coveralls]

Pull Request Test Coverage Report for Build 19822144009

Details

• 91 of 130 (70.0%) changed or added relevant lines in 3 files are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage increased (+2.1%) to 22.309%

---

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
namer/generatorvalidator.go	48	87	55.17%

Totals
Change from base Build 19701817310:	2.1%
Covered Lines:	688
Relevant Lines:	3084

---

💛 - Coveralls

[oleg-jukovec]

api: implement namer, generator, validator

Please, change the commit title and the PR title.

[elhimov]

So we generate names and then parse them with another method of the same class. At the moment it looks like we decode what we have just encoded. If it is the only planned usage of such classes I'd suggest to have a kind of single GenerateKeys method that generates keys from name instead of 2-phase transformation name->names->keys.

[bigbes]

Have a small discussion with @patapenka-alexey about how to reorganize package:

type key struct {
    name     string   // Object identifier
    type     KeyType  // Type of object (hash/signature/value)
    property string   // Additional metadata (version/algorithm)
    raw      string   // Raw key string
}

type Key interface {
    Name()     string   // Get object name
    Type()     KeyType  // Get key type
    Property() string   // Get metadata (e.g., algorithm version)
    Build()    string   // Reconstruct raw key string
}

type DefaultNamer struct {
    prefix string // Key prefix (e.g., "storage/")
}

// Constructor with hash/signature name configurations
func NewDefaultNamer(prefix string, hashNames, sigNames []string) *DefaultNamer

// Methods:
// - Generate all keys for an object name
func (n *DefaultNamer) GenerateNames(name string) []Key {}

// - Parse multiple raw keys into grouped results
func (n *DefaultNamer) ParseNamesMulti(names []string) ParseNamesResult {}

type ParseNamesResult 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
}

// Helper methods:
// - Get keys for single-name case (if applicable)
func (r *ParseNamesResult) SelectSingle() ([]Key, bool)

// - Iterate over all name→keys groups
func (r *ParseNamesResult) Iter() iter.Seq2[string, []Key]

// - Get keys for a specific object name
func (r *ParseNamesResult) Select(name string) ([]Key, bool)

// - Count unique object names
func (r *ParseNamesResult) Len() int

Signing/Generation Workflow

1. Input: object name + value.
2. Process:
   • Generate all keys via DefaultNamer.GenerateNames(name).
   • For each generated Key:
     • If KeyType = signature: generate cryptographic signature
     • If KeyType = hash: compute hash of value
     • If KeyType = value: marshal raw data
3. Output: []KeyValue records.

Validation Workflow

1. Input: []KeyValue records (optionally indexed via map[string]KeyValue).
2. Process:
   • Parse all keys using DefaultNamer.ParseNamesMulti().
   • Group keys by original object name.
   • For each object name group:
     • Validate signatures/hashes using Key.Build() to reconstruct original keys
3. Output: validated values (single or multiple objects).

This code decomposition and API will help us test code, will make clearer separation of "parsing/generation/validation" logic.

Note 1

SelectSingle might be unnecessary – consider replacing ParseNamesResult with map[string][]Key if single-name access isn't critical.

Note 2

Parsing logic centralized in keyFromString(key string) key, which:

• Checks prefixes (e.g., strings.HasPrefix(key, "<prefix>/hash"))
• Automatically infers key types and metadata

[elhimov]

It will remove not only prefix, but all occurrences of n.prefix substring.
And what if name does not start with n.prefix?

Suggested change

	result := strings.ReplaceAll(name, n.prefix, "")
	result, found := strings.CutPrefix(name, n.prefix)
	if !found {
	continue // or something similar
	}