go-rel/rel

package rel

import (
    "fmt"
    "time"
)

var (
    Now NowFunc = func() time.Time {
        return time.Now().Truncate(time.Second)
    }
)

// NowFunc is the type of function that returns the current time.
type NowFunc func() time.Time

// Structset can be used as mutation for repository insert or update operation.
// This will save every field in struct and it's association as long as it's loaded.
// This is the default mutator used by repository.
type Structset struct {
    doc      *Document
    skipZero bool
}

// Apply mutation.
func (s Structset) Apply(doc *Document, mut *Mutation) {
    var (
        pFields = s.doc.PrimaryFields()
        t       = Now()
    )

    for _, field := range s.doc.Fields() {
        switch field {
        case "created_at", "inserted_at":
            if doc.Flag(HasCreatedAt) {
                if value, ok := doc.Value(field); ok && value.(time.Time).IsZero() {
                    s.set(doc, mut, field, t, true)
                    continue
                }
            }
        case "updated_at":
            if doc.Flag(HasUpdatedAt) {
                s.set(doc, mut, field, t, true)
                continue
            }
        }

        if len(pFields) == 1 && pFields[0] == field {
            // allow setting primary key as long as it's not zero.
            s.applyValue(doc, mut, field, true)
        } else {
            s.applyValue(doc, mut, field, s.skipZero)
        }
    }

    if mut.Cascade {
        s.applyAssoc(mut)
    }
}

func (s Structset) set(doc *Document, mut *Mutation, field string, value any, force bool) {
    if (force || doc.v != s.doc.v) && !doc.SetValue(field, value) {
        panic(fmt.Sprint("rel: cannot assign ", value, " as ", field, " into ", doc.Table()))
    }

    mut.Add(Set(field, value))
}

func (s Structset) applyValue(doc *Document, mut *Mutation, field string, skipZero bool) {
    if value, ok := s.doc.Value(field); ok {
        if skipZero && isZero(value) {
            return
        }

        s.set(doc, mut, field, value, false)
    }
}

func (s Structset) applyAssoc(mut *Mutation) {
    for _, field := range s.doc.BelongsTo() {
        s.buildAssoc(field, mut)
    }

    for _, field := range s.doc.HasOne() {
        s.buildAssoc(field, mut)
    }

    for _, field := range s.doc.HasMany() {
        s.buildAssocMany(field, mut)
    }
}

func (s Structset) buildAssoc(field string, mut *Mutation) {
    assoc := s.doc.Association(field)
    if assoc.IsZero() {
        return
    }

    var (
        doc, _ = assoc.Document()
    )

    mut.SetAssoc(field, Apply(doc, newStructset(doc, s.skipZero)))
}

func (s Structset) buildAssocMany(field string, mut *Mutation) {
    assoc := s.doc.Association(field)
    if assoc.IsZero() {
        return
    }

    var (
        col, _ = assoc.Collection()
        muts   = make([]Mutation, col.Len())
    )

    for i := range muts {
        var (
            doc = col.Get(i)
        )

        muts[i] = Apply(doc, newStructset(doc, s.skipZero))
    }

    mut.SetAssoc(field, muts...)
}

func newStructset(doc *Document, skipZero bool) Structset {
    return Structset{
        doc:      doc,
        skipZero: skipZero,
    }
}

// NewStructset from a struct.
func NewStructset(entity any, skipZero bool) Structset {
    return newStructset(NewDocument(entity), skipZero)
}