Dynamic CUE generation using command line parameters

[richardpeng]

Is there a way to dynamically interact with CUE? I want to pass feature flags on the command line to enable things in CUE. I'm working to replace Helm charts with CUE and am not finding a straightforward way to implement values which I use to conditionally enable/disable environment variables, Kubernetes resources, etc. I wrote a Go script to do what I want but wasn't sure if this was already possible in pure CUE

Example Usages

Enable feature1

go run ./fill.go "features=[\"feature1\"]" 

Output:

{
        features: ["feature1"]
        application: {
                feature1: "enabled"
        }
}

Insert arbitrary data

go run ./fill.go "arbitrary=\"data\""

Output:

{
        features: [...string]
        arbitrary: "data"
        application: {}
}

base.cue

package main

import (
	"list"
)

features: [...string]
application: {}

if list.Contains(features, "feature1") {
	application: feature1: "enabled"
}

if list.Contains(features, "feature2") {
	application: feature2: "enabled"
}

fill.go

package main

import (
	"cuelang.org/go/cue"
	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/load"
	"fmt"
	"os"
	"strings"
)

func main() {
	// We need a cue.Context for building after loading
	ctx := cuecontext.New()

	params := os.Args[1:]

	// Load Cue files into Cue build.Instances slice
	// the second arg is a configuration object, we'll see this later
	bis := load.Instances([]string{"."}, nil)
	bi := bis[0]

	// check for errors on the instance
	// these are typically parsing errors
	if bi.Err != nil {
		fmt.Println("Error during load:", bi.Err)
		os.Exit(1)
	}

	// Use cue.Context.BuildInstance to turn
	// a build.Instance into a cue.Value
	value := ctx.BuildInstance(bi)
	if value.Err() != nil {
		fmt.Println("Error during build:", value.Err())
		os.Exit(1)
	}

	for _, arg := range params {
		split := strings.Split(arg, "=")
		path := split[0]
		argValue := split[1]

		unmarshal := ctx.CompileString(argValue)
		err := unmarshal.Err()
		if err != nil {
			fmt.Println("Unable to compile arg:", err)
			os.Exit(1)
		}

		value = value.FillPath(cue.ParsePath(path), unmarshal)
		err = value.Err()
		if value.Err() != nil {
			fmt.Println("Error during filling:", err)
			os.Exit(1)
		}
	}

	// Validate the value
	err := value.Validate()
	if err != nil {
		fmt.Println("Error during validation:", err)
		os.Exit(1)
	}

	// Print the value
	fmt.Println(value)
}

[myitcv]

@richardpeng - have you seen the support for injecting values into CUE, via cmd/cue?

$ cue help injection

The equivalent mechanism via cue/load is the Tags field:

https://pkg.go.dev/cuelang.org/go/cue/load#Config

[richardpeng]

@myitcv I had not seen those docs, but that's great! However, I couldn't figure out how to inject lists. Is that possible? Otherwise, we can use a different data structure like:

features: {
  feature1: *false | true @tag(feature1,type=bool)
  feature2: *false | true @tag(feature2,type=bool)
}

[richardpeng]

I actually ended up with a structure that doesn't use lists anyway:

#ServiceStatus: "install" | "upgrade" | *"disabled"
services: [string]: #ServiceStatus
services: myservice: #ServiceStatus @tag(myservice)

if services.myservice != "disabled" {
  myservice: enabled: true
}
if services.myservice == "install" {
  myservice: install: true
}
if services.myservice == "upgrade" {
  myservice: upgrade: true
}

cue eval -t myservice=install
cue eval -t myservice=upgrade

[myitcv]

Glad you found something that works.

FWIW, lists and structs are not currently supported by the injection mechanism, largely because it's not clear how to make that cleanly work. However they can be made to work via something like:

exec cue export -t list=[1,2,3]
cmp stdout stdout.golden

-- x.cue --
package x

import "encoding/json"

x: string @tag(list)
y: json.Unmarshal(x)[0]
-- stdout.golden --
{
    "x": "[1,2,3]",
    "y": 1
}