TLDR; Checkout a generic form here: https://github.com/ryanfaerman/can

I'll show you what I came up with first and then, a slightly more generic version.

Let's define a couple interfaces and a model:

// Canner allows a resource to define if an account can perform 
// a given action.
type Canner interface {
    Can(account *Account, action string) error
}

// Verber is used to allow a resource to define the actions 
// it supports.
type Verber interface {
    Verbs() []string
}

type Account {
    ID        int
    Name      string
    Anonymous bool
    // ... use your actual model
}

var AnonymousAccount = Account{ID: -1, Name: "Anon", Anonymous: true}

And while we're at it, a basic container type:

// Policy is a map of actions to functions that
// return an error if the action cannot be performed for the 
// given account.
type Policy map[string]func(*Account) error

// Verbs implements the Verber interface.
func (p Policy) Verbs() []string {
    var verbs []string
    for verb := range p {
        verbs = append(verbs, verb)
    }
    return verbs
}

// Can implements the Canner interface.
func (p Policy) Can(account *Account, action string) error {
    if fn, ok := p[action]; ok {
        return fn(account)
    }
    return nil
}

// An example default policy.
var DefaultPolicy = Policy{
    // Anonymous users aren't allowed to view anything
    "view": func(account *Account) error {
        if account.Anonymous {
            return errors.New("must not be anonymous")
        }
    },

    // Editing is disabled for everyone
    "edit": func(account *Account) error {
        return errors.New("editing is forbidden")
    },
}

And, let's also create an example subject that we want to act on:

type BlogPost struct {
    Title string
    Body  string
    Owner *Account
}

func (b *BlogPost) Verbs() []string {
    return []string{"view", "edit", "promote", "delete"}
}

func (b *BlogPost) Can(account *Account, action string) error {
    switch action {
        case "view":
            // anyone can view
            return nil
        case "edit"
            if b.Owner.ID != account.ID {
                return errors.New("cannot edit someone elses blogpost")
            }
            return nil
        // case ...
    }
    return nil
}

Now with those few things, we can build out the actual function that makes this idea work:

func Can(account *Account, action string, resources ...any) error {
    if account == nil {
        account = AnonymousAccount
    }
    if len(resources) == 0 {
        resources = append(resources, DefaultPolicy)
    }

    for _, resource := range resources {
        if r, ok := resource.(Verber); ok {
            if !slices.Contains(r.Verbs(), action) {
                return ErrInvalidAction
            }
        }

        if r, ok := resource.(Canner); ok {
            if err := r.Can(account, action); err != nil {
                return errors.Join(ErrNotAuthorized, err)
            }
        }
    }

    return nil
}

// Some sugar!
func Cannot(account *Account, action string, resources ...any) error {
    !Can(account, action, resources...)
}

Now, scattered in our codebase we can do things like:

// ..
b := LoadBlogPost()
if Cannot(someAccount, "edit", b) {
    //... do something
}

Granted, this is partially contrived. In my application I'm using an actual model, not just a random struct, but most of it is pretty similar to what I have.

Two more fun things before we wrap this up.

If you're using templ, like I am, I made a couple helpers.

func CurrentAccount(ctx context.Context) *models.Account {
    // Get the current user from the account
    // Or return an AnonymousUser
}

func UserCan(ctx context.Context, action string, resources ...any) bool {
    if err := services.Authorization.Can(CurrentAccount(ctx), action, resources...); err != nil {
        return false
    }
    return true
}

templ Can(action string, resources ...any) {
    if UserCan(ctx, action, resources...) {
        { children... }
    }
}

templ Cannot(action string, resources ...any) {
    if !UserCan(ctx, action, resources...) {
        { children... }
    }
}

// in some templ file:

@Can("edit", theBlogPost) {
    <h1>You can Edit this!</h1>
}
@Cannot("edit", theBlogPost) {
    <h1>Sorry bud! You cannot do that</h1>
}

I've split up the UserCan from Can and Cannot because doing assignments and error checking is a bit of a pain in templ.

If you want to see this in a less of a contrived fashion, you can view it in action in my application: https://github.com/ryanfaerman/netctl/blob/master/internal/services/authorization.go

I've also made a simple package with a generic form here: https://github.com/ryanfaerman/can

The JSON of a valid callsign is as follows (redacted for privacy):

{  
   "hamdb":{  
      "version":"1",
      "callsign":{
         "call":"redacted",
         "class":"E",
         "expires":"09/25/2025",
         "status":"A",
         "grid":"redacted",
         "lat":"redacted",
         "lon":"redacted",
         "fname":"redacted",
         "mi":"redacted",
         "name":"redacted",
         "suffix":"redacted",
         "addr1":"redacted",
         "addr2":"redacted",
         "state":"redacted",
         "zip":"redacted",
         "country":"United States"
      },
      "messages":{
         "status":"OK"
      }
   }
}

But look what happens when you query for a callsign that can't be found:

{  
   "hamdb":{  
      "version":"1",
      "callsign":{
         "call":"NOT_FOUND",
         "class":"NOT_FOUND",
         "expires":"NOT_FOUND",
         "status":"NOT_FOUND",
         "grid":"NOT_FOUND",
         "lat":"NOT_FOUND",
         "lon":"NOT_FOUND",
         "fname":"NOT_FOUND",
         "mi":"NOT_FOUND",
         "name":"NOT_FOUND",
         "suffix":"NOT_FOUND",
         "addr1":"NOT_FOUND",
         "addr2":"NOT_FOUND",
         "state":"NOT_FOUND",
         "zip":"NOT_FOUND",
         "country":"NOT_FOUND"
      },
      "messages":{
         "status":"NOT_FOUND"
      }
   }
}

Every field is NOT_FOUND. This makes unmarshalling that data into a struct a real challenge. The expires field can be either a parseable date or a string!

The solution I came up with was to introduce a new generic type that can handle this behavior:

type Unknowable[K comparable] struct {
    Value K
    Known bool
}

func (u *Unknowable[K]) UnmarshalJSON(b []byte) error {
    s := strings.Replace(string(b), `"`, ``, -1)
    switch s {
    case "NOT_FOUND":
        u.Known = false
        return nil
    default:
        u.Known = true
        var v K

        switch any(v).(type) {
        case float64:
            f, err := strconv.ParseFloat(s, 64)
            if err != nil {
                return err
            }
            v = any(f).(K)

        case int:
            f, err := strconv.Atoi(s)
            if err != nil {
                return err
            }
            v = any(f).(K)

        default:
            if err := json.Unmarshal(b, &v); err != nil {
                return err
            }
        }

        u.Value = v
    }
    return nil
}

The goofy any(v).(type) switch is because I couldn't quite figure out how to get the concrete types to parse correctly without doing something different to each of them. This is partly because I wanted to have real types for things like the lat and lon, not just strings.

Now I can represent the types I want to unmarshal within the destination struct directly.

type Callsign struct {
    Call          string                `json:"call"`
    Class         LicenseClass          `json:"class"`
    Expires       Unknowable[time.Time] `json:"expires"`
    Status        string                `json:"status"`
    Grid          string                `json:"grid"`
    Lat           Unknowable[float64]   `json:"lat"`
    Lon           Unknowable[float64]   `json:"lon"`
    FirstName     string                `json:"fname"`
    MiddleInitial string                `json:"mi"`
    LastName      string                `json:"name"`
    Suffix        string                `json:"suffix"`
    Address       string                `json:"addr1"`
    City          string                `json:"addr2"`
    State         string                `json:"state"`
    Zip           Unknowable[int]       `json:"zip"`
    Country       string                `json:"country"`
}

This is one of those times where generics in Go has been super helpful. Granted, I'd still like a way to type-switch on a constraint, but this is still much cleaner than having multiple types with nearly identical implementations and names.