Feature Request: Support setting composite fields (SetField)

[Stashchenko]

Current Behavior

The current method:

func (m *Message) Field(id int, val string)

only works for simple field types. There is no straightforward way to set values for composite fields that have subfields.

---

Proposal

Introduce a new method like:

func (m *Message) SetField(path string, val string) error

• path: a string representing the field and optional subfield, e.g., "3.01" for field 3, subfield 01.
• The method should automatically detect whether the target is a simple field or a composite field and set the value appropriately.

---

Example Usage

func TestMessage_SetField(t *testing.T) {
    // Define field 3 as a composite field, it's the hack but just for example 
    Spec87.Fields[3] = field.NewComposite(&field.Spec{
        Length:      6,
        Description: "Processing Code",
        Pref:        prefix.ASCII.Fixed,
        Tag: &field.TagSpec{ Sort: sort.Strings },
        Subfields: map[string]field.Field{
            "01": field.NewString(&field.Spec{
                Length:      2,
                Description: "Cardholder Transaction Type Code",
                Enc:         encoding.ASCII,
                Pref:        prefix.ASCII.Fixed,
            }),
            "02": field.NewString(&field.Spec{
                Length:      2,
                Description: "Cardholder “From Account” Type Code",
                Enc:         encoding.ASCII,
                Pref:        prefix.ASCII.Fixed,
            }),
            "03": field.NewString(&field.Spec{
                Length:      2,
                Description: "Cardholder “To Account” Type Code",
                Enc:         encoding.ASCII,
                Pref:        prefix.ASCII.Fixed,
            }),
        },
    })

    message := iso8583.NewMessage(Spec87)
    // unpack and all the check on real data
    // _ = message.Unpack(someData)
   
    // Set a value into a subfield to modify the data
    err := message.SetField("3.01", "10")
    require.NoError(t, err)
}

---

Benefits

• Makes it easy to work with composite fields without manually drilling into subfields.
• Keeps a clean and consistent API for both simple and composite fields.

[Stashchenko]

I made the PoC locally:

add to Composite

// SetSubfields sets the value of a subfield identified by its path in the format "a.b.c".
// It supports nested composite fields and marks the subfield as set for inclusion in
// operations like Pack() or Marshal().
func (m *Composite) SetSubfields(idPath string, value string) error {
 if idPath == "" {
  return fmt.Errorf("subfield path cannot be empty")
 }

 id, path, _ := strings.Cut(idPath, ".")

 subfield, ok := m.subfields[id]
 if !ok {
  return fmt.Errorf("subfield %s does not exist", id)
 }

 // If there's no further path, set the value directly
 if len(path) == 0 {
  return m.setSubfield(id, value)
 }

 // If there's a further path, the subfield must be a composite
 composite, ok := subfield.(*Composite)
 if !ok {
  return fmt.Errorf("subfield %s is not a composite field and cannot have nested subfields", id)
 }

 // Mark this subfield as set since we're setting a nested value
 m.setSubfields[id] = struct{}{}

 // Recursively set the nested subfield
 return composite.SetSubfields(path, value)
}

// setSubfield sets the value of a subfield identified by its ID.
// It marks the subfield as set for inclusion in operations like Pack() or Marshal().
func (m *Composite) setSubfield(id string, value string) error {
 m.mu.Lock()
 defer m.mu.Unlock()

 subfield, ok := m.subfields[id]
 if !ok {
  return fmt.Errorf("subfield %s does not exist", id)
 }

 if err := subfield.SetBytes([]byte(value)); err != nil {
  return fmt.Errorf("failed to set subfield %s: %w", id, err)
 }

 m.setSubfields[id] = struct{}{}
 return nil
}
 

add to Message

// SetField sets the value of a field or subfield identified by its path.
// For simple fields, use just the field ID as a string (e.g., "3").
// For composite fields with subfields, use dot notation (e.g., "3.01" for field 3, subfield 01).
// The method automatically detects whether the target is a simple field or a composite field.
func (m *Message) SetField(path string, val string) error {
 m.mu.Lock()
 defer m.mu.Unlock()

 if path == "" {
  return fmt.Errorf("field path cannot be empty")
 }

 // Parse the field ID from the path
 fieldIDStr, subPath, hasSubPath := strings.Cut(path, ".")

 fieldID, err := strconv.Atoi(fieldIDStr)
 if err != nil {
  return fmt.Errorf("invalid field ID '%s': %w", fieldIDStr, err)
 }

 // Check if the field exists
 f, ok := m.fields[fieldID]
 if !ok {
  return fmt.Errorf("field %d does not exist", fieldID)
 }

 // Mark the field as set
 m.fieldsMap[fieldID] = struct{}{}

 // If there's no subpath, treat it as a simple field
 if !hasSubPath {
  return f.SetBytes([]byte(val))
 }

 // If there's a subpath, the field must be a composite
 composite, ok := f.(*field.Composite)
 if !ok {
  return fmt.Errorf("field %d is not a composite field and cannot have subfields", fieldID)
 }

 // Set the subfield value using the composite's SetSubfields method
 return composite.SetSubfields(subPath, val)
}

works as expected yet didn't have time to finish and tests more