synapsecns/sanguine

package dbcommon

import (
    "fmt"
    "gorm.io/gorm"
    "reflect"

    "github.com/fatih/structtag"
    "gorm.io/gorm/schema"
)

// getGormFieldName gets a gorm field name by name
// it panics if the field cannot be found or if the tag is not available
//
// note: this should only be called on init. See package docs for an explanation
// of this pattern. Ideally - all struct names map 1:1 with a field name consistently.
// please use caution before using this directly anywhere
//
// TODO: it'd be ideal if more of this could be done by the gorm schema parser.
func getGormFieldName(model interface{}, fieldName string) string {
    field, ok := reflect.TypeOf(model).Elem().FieldByName(fieldName)
    if !ok {
        panic(fmt.Sprintf("could not get field %s on struct %s. Does this field exist?", fieldName, reflect.TypeOf(model)))
    }

    tags, err := structtag.Parse(string(field.Tag))
    if err != nil {
        panic(fmt.Errorf("could not parse struct tag: %s, got error: %w", string(field.Tag), err))
    }

    gormTag, err := tags.Get("gorm")
    // no tag at all, return the field name
    if err != nil {
        return schema.NamingStrategy{}.ColumnName("", fieldName)
    }

    // create a empty schema, this is only used for setting errors in the parse field function
    // these errors are not exported, but currently will not happen here if migrations are successful
    // (a pre-requisite to running the node). See: https://git.io/JW6by for details
    emptySchema := schema.Schema{}
    parsedField := emptySchema.ParseField(field)

    // if the field (column like type) can be parsed, return it otherwise
    // the user is using gorm:COLUMN_NAME pattern and we can return the tag name.
    if parsedField.DBName == "" {
        return gormTag.Name
    }

    return parsedField.DBName
}

// Namer is used to pull consistent names for fields from models. This prevents inconsistency by panicing on breaking changes.
// It also allows us to avoid using xModelFieldName, yModelFieldName by taking advantage of introspection.
type Namer struct {
    models []interface{}
}

// NewNamer creates a new namer.
func NewNamer(models []interface{}) Namer {
    return Namer{models: models}
}

// GetConsistentName makes sure a `ColumnName` has a common column tag against all models
// we use this so we don't have to define bridgeRedeemModelFieldName, originChainFieldName, etc.
// panic's on an inconsistency. Note: this should only be called from init.
//
// after this is called, you can safely call getGormFieldName(AnyModelWithField, fieldName)
// if all fields cannot make this guarantee, they should be separated out to avoid developer confusion.
//
// this returns the result of getGormFieldName for a valid model. It also panics if no model is valid
// todo consider generating getters for all field names.
func (n Namer) GetConsistentName(fieldName string) string {
    var (
        // lastFoundModel is the interface where the model was last found
        // this is used for logging differences between two models
        lastFoundModel interface{}
        // lastTagName in the loop
        lastTagName string
        // whether or not a tag name has been found
        foundTagName bool
    )

    for _, model := range n.models {
        // check if the model has the field
        _, ok := reflect.TypeOf(model).Elem().FieldByName(fieldName)
        if !ok {
            continue
        }
        newTagName := getGormFieldName(model, fieldName)
        if !foundTagName {
            foundTagName = true
            lastTagName = newTagName
            lastFoundModel = model
            continue
        }

        if newTagName != lastTagName {
            panic(fmt.Sprintf("error asserting name consistency on field name %s. Model %s has tag name set "+
                "to %s, but model %s has tag name set to %s. See getConsistentName/package docs for details",
                fieldName, reflect.TypeOf(model).Name(), newTagName, reflect.TypeOf(lastFoundModel), lastTagName))
        }
        lastFoundModel = model
    }

    if !foundTagName {
        panic(fmt.Errorf("did not find any models with field name %s", fieldName))
    }

    return getGormFieldName(lastFoundModel, fieldName)
}

// GetModelName returns the name of the model.
func GetModelName(db *gorm.DB, model interface{}) (string, error) {
    if reflect.ValueOf(model).Kind() != reflect.Ptr {
        return "", fmt.Errorf("model must be a pointer, type is %T", model)
    }

    tableNameStmt := db.Model(model).Statement
    err := tableNameStmt.Parse(model)
    if err != nil {
        return "", fmt.Errorf("failed to parse model: %w", err)
    }

    return tableNameStmt.Schema.Table, nil
}