How to map CUE defs onto Go structs, in particular nested extension of values

[verdverm]

Say I have the following

• A set of CUE defs
• Go types meant to match the CUE defs
• A CUE instances of a specialize def
• Some Go code to decode the value into structs

What's the right way to set this up?

CUE Defs

package inv

#Inv: {

	apiVersion: "com.verdverm.inventory/v1beta1"
	kind:       string

	metadata: {
		name: string
		labels: [string]: string
  }

  spec: {
    // pack: {...}
    ci: {
      build:  bool | *true
      test:   bool | *true
      lint:   bool | *true
      push:   bool | *true
    }
    run: {
      deploy: bool | *false
      env:    string | *"dev"
    }
  }
}

#Binary: {
  #Inv
  kind: "Binary"

  // extensions
  M=metadata: {
    binaryName: string | *M.name
  }
}

#Service: {
  #Inv
  kind: "Service"

  // extensions
  spec: run: port: int | *4242
}

Go Types

package main

type Base struct {
	ApiVersion string `json:"apiVersion"`
	Kind       string `json:"kind"`

	Metadata Metadata `json:"metadata"`
	Spec     Spec     `json:"spec"`
}

type Metadata struct {
	Name   string            `json:"name"`
	Labels map[string]string `json:"labels"`
}

type Spec struct {
	CI  SpecCI  `json:"ci"`
	Run SpecRun `json:"run"`
}

type SpecCI struct {
	Build bool `json:"build"`
	Test  bool `json:"test"`
	Lint  bool `json:"lint"`
	Push  bool `json:"push"`
}

type SpecRun struct {
	Deploy bool   `json:"deploy"`
	Env    string `json:"env"`
}

type Binary struct {
	Base
	Metadata struct {
		BinaryName string `json:"binaryName"`
	} `json:"metadata"`
}

type Service struct {
	Base
	Spec struct {
		Run struct {
			Port int `json:"port"`
		} `json:"run"`
	} `json:"spec"`
}

CUE Instance

package main

import "verdverm.com/inv"

inv.#Service

metadata: {
  name: "foo"
}

Go Program

package main

import (
	"fmt"
	"os"

	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/load"
	"github.com/kr/pretty"
)

func check(err error) {
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func main() {
	fmt.Println("inv")
	ctx := cuecontext.New()

	// load some cue
	bis := load.Instances([]string{"main.cue"}, nil)
	val := ctx.BuildInstance(bis[0])
	check(val.Err())
	fmt.Printf("%+v\n", val)

	// decode into go
	var s Service
	err := val.Decode(&s)
	check(err)
	fmt.Printf("%# v\n", pretty.Formatter(s))

	fmt.Printf("%q %d\n",
		s.Base.Spec.Run.Env,           ////  <==== DONT want to write "Base" here, data is not decoding
		s.Spec.Run.Port,
	)
}

Output

➜  code git:(main) ✗  
go run ./
inv
{
        apiVersion: "com.verdverm.inventory/v1beta1"
        kind:       "Service"
        metadata: {
                name: "foo"
                labels: {}
        }
        spec: {
                ci: {
                        build: true
                        test:  true
                        lint:  true
                        push:  true
                }
                run: {
                        deploy: false
                        env:    "dev"
                        port:   4242
                }
        }
}
main.Service{
    Base: main.Base{
        ApiVersion: "com.verdverm.inventory/v1beta1",
        Kind:       "Service",
        Metadata:   main.Metadata{
            Name:   "foo",
            Labels: {},
        },
        Spec: main.Spec{},
    },
    Spec: struct { Run struct { Port int "json:\"port\"" } "json:\"run\"" }{
        Run: struct { Port int "json:\"port\"" }{Port:4242},
    },
}
"" 4242

[myitcv]

I would use @mvdan's new cue exp gengotypes in the first instance:

# check main CUE package
exec cue export .
cmp stdout cue.stdout.golden

# generate Go types from CUE
exec cue exp gengotypes ./inv

# run Go program
exec go mod tidy
exec go run .
cmp stdout go.stdout.golden

-- cue.mod/module.cue --
module: "verdverm.com"
language: {
	version: "v0.12.0"
}
-- go.mod --
module verdverm.com

go 1.23.5

require (
	cuelang.org/go v0.12.0
	github.com/kr/pretty v0.3.1
)

-- inv/inv.cue --
package inv

#Inv: {

	apiVersion: "com.verdverm.inventory/v1beta1"
	kind:       string

	metadata: {
		name: string
		labels: [string]: string
	}

	spec: {
		// pack: {...}
		ci: {
			build: bool | *true
			test:  bool | *true
			lint:  bool | *true
			push:  bool | *true
		}
		run: {
			deploy: bool | *false
			env:    string | *"dev"
		}
	}
}

#Binary: {
	#Inv
	kind: "Binary"

	// extensions
	M=metadata: {
		binaryName: string | *M.name
	}
}

#Service: {
	#Inv
	kind: "Service"

	// extensions
	spec: run: port: int | *4242
}
-- main.cue --
package main

import "verdverm.com/inv"

inv.#Service

metadata: {
	name: "foo"
}
-- main.go --
package main

import (
	"fmt"
	"os"

	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/load"
	"github.com/kr/pretty"
	"verdverm.com/inv"
)

func check(err error) {
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func main() {
	fmt.Println("inv")
	ctx := cuecontext.New()

	// load some cue
	bis := load.Instances([]string{"main.cue"}, nil)
	val := ctx.BuildInstance(bis[0])
	check(val.Err())
	fmt.Printf("%+v\n", val)

	// decode into go
	var s inv.Service
	err := val.Decode(&s)
	check(err)
	fmt.Printf("%# v\n", pretty.Formatter(s))

	fmt.Printf("%q %d\n",
		s.Spec.Run.Env,
		s.Spec.Run.Port,
	)
}

-- cue.stdout.golden --
{
    "apiVersion": "com.verdverm.inventory/v1beta1",
    "kind": "Service",
    "metadata": {
        "name": "foo",
        "labels": {}
    },
    "spec": {
        "ci": {
            "build": true,
            "test": true,
            "lint": true,
            "push": true
        },
        "run": {
            "deploy": false,
            "env": "dev",
            "port": 4242
        }
    }
}
-- go.stdout.golden --
inv
{
	apiVersion: "com.verdverm.inventory/v1beta1"
	kind:       "Service"
	metadata: {
		name: "foo"
		labels: {}
	}
	spec: {
		ci: {
			build: true
			test:  true
			lint:  true
			push:  true
		}
		run: {
			deploy: false
			env:    "dev"
			port:   4242
		}
	}
}
inv.Service{
    ApiVersion: "com.verdverm.inventory/v1beta1",
    Kind:       "Service",
    Metadata:   struct { Name string "json:\"name\""; Labels map[string]string "json:\"labels\"" }{
        Name:   "foo",
        Labels: {},
    },
    Spec: struct { Ci struct { Build bool "json:\"build\""; Test bool "json:\"test\""; Lint bool "json:\"lint\""; Push bool "json:\"push\"" } "json:\"ci\""; Run struct { Deploy bool "json:\"deploy\""; Env string "json:\"env\""; Port int64 "json:\"port\"" } "json:\"run\"" }{
        Ci:  struct { Build bool "json:\"build\""; Test bool "json:\"test\""; Lint bool "json:\"lint\""; Push bool "json:\"push\"" }{Build:true, Test:true, Lint:true, Push:true},
        Run: struct { Deploy bool "json:\"deploy\""; Env string "json:\"env\""; Port int64 "json:\"port\"" }{Deploy:false, Env:"dev", Port:4242},
    },
}
"dev" 4242

Which I think gives you what you want?

Docs at https://cuelang.org/docs/reference/command/cue-help-exp-gengotypes/, example on cuelang.org to follow (cc @jpluscplusm)

[verdverm]

Well, it's not DRY, but does build out the full types

I imagine this will be helpful regardless

If I pull out the metadata into its own Def, it produces less ideal Go types

#Metadata: {
  name: string
  labels: [string]: string

  casing: {
    snake: strings.Replace(name, "-", "_", -1)
    kebab: strings.Replace(name, "_", "-", -1)
  }
  ...
}


#Inv: {

	apiVersion: "com.verdverm.inventory/v1beta1"
	kind:       string

  metadata: #Metadata

type Metadata map[string]any /* CUE top */

type Inv struct {
	ApiVersion string `json:"apiVersion"`

	Kind string `json:"kind"`

	Metadata Metadata `json:"metadata"`


...


type Binary struct {
	ApiVersion string `json:"apiVersion"`

	Kind string `json:"kind"`

	// extensions
	Metadata map[string]any/* CUE top */ `json:"metadata"`

[verdverm]

One thing I'm unsure of, in the original version, where all the nested structs are defined inline, will I be able to build a slice of Metadata across the #Components disjunction allowed types in Go?

[jpluscplusm]

example on cuelang.org to follow

Tracked as cue-lang/docs-and-content#200.

[verdverm]

FYI, the gengotypes does not like "hyphenated-keys": { ... }

[verdverm]

I see there are @go() attributes I can use, nice!

It would be helpful to provide the output filepath as an optional flag

cc @mvdan