Basic groups

A "Basic group" is any type that implements Parsable. When referenced by an "Automation module"'s Parameter, the frontend interface for this group will be created.

This type is designed to streamline mass user input for things like proxy lists (handled by default), lists of accounts, etc. that all need to be in a certain format.

All parsing/serializing is handled clientside the moment the end user clicks save as well as on the server using the exact same Golang logic with the power of Webassembly. All that needs to be done special in the implementation file(s) is adding the frontend tag:

//frontend

package ...

To make sure the client binary only includes the necessary logic.

This allows for quick development on lists complex types, without worrying about having to write a validator in JS or needing validation to happen on the server.

Example

This example is of an "Account" type which accepts strings using the following CFG:

AccountEntry       ::= TwoForm [ ":" Phone ]
                     | FourForm [ ":" Phone ]
                     ;

TwoForm            ::= Segment ":" Segment
                     ;

FourForm           ::= Segment ":" Segment ":" Segment ":" Segment
                     ;

Phone              ::= Segment  ;  (* must satisfy external phonenumbers.Parse *)
                     ;

Segment            ::= 1*( any character except ":" )
                     ;

The phone number parsing is able to be handled by the external library, without any additional code. It just works like so:

//frontend

package account

import (
	"errors"
	"strconv"
	"strings"

	basicgroupsprotocol "github.com/futura-platform/protocol/basicgroups/protocol"
	"github.com/nyaruka/phonenumbers"
)

type Account struct {
	ImapEmail    string
	ImapPassword string

	Email    string
	Password string

	Phone *phonenumbers.PhoneNumber
}

func (Account) ParseEntry(u string) (Account, error) {
	spl := strings.Split(u, ":")
	switch len(spl) {
	case 2, 3:
		a := Account{
			ImapEmail: spl[0],
			Email:     spl[0],

			ImapPassword: spl[1],
			Password:     spl[1],
		}
		if len(spl) == 3 {
			phone, err := phonenumbers.Parse(spl[2], "US")
			if err != nil {
				return Account{}, errors.New("failed to parse phone number: " + err.Error())
			}
			a.Phone = phone
		}
		return a, nil
	case 4, 5:
		a := Account{
			ImapEmail:    spl[0],
			ImapPassword: spl[1],

			Email:    spl[2],
			Password: spl[3],
		}
		if len(spl) == 5 {
			phone, err := phonenumbers.Parse(spl[4], "US")
			if err != nil {
				return Account{}, errors.New("failed to parse phone number: " + err.Error())
			}
			a.Phone = phone
		}
		return a, nil
	default:
		return Account{}, errors.New("failed to parse account: got " + strconv.Itoa(len(spl)) + " sections")
	}
}

...

Now if the user enters an invalid phone number, we can rely on the github.com/nyaruka/phonenumbers library to handle the parsing, and always have the type safe result available to tasks that reference this group.