how to disable cue instance validation in go api?

[sahroshan]

Hi,

I am using golang api to fill some values in cue. I would like to fill any values for an instance and later validate once the cue is complete.

Please refer to below code. The code throws error as "" does not comply to regex.
Any help would beapp

package main

import (
	"fmt"

	"cuelang.org/go/cue/cuecontext"
)

const input = `
{
	cpu:     =~"^\\d{4}$"
}
`

func fill() {
	ctx := cuecontext.New()
	inp := ctx.CompileString(input)
	v := inp.Lookup("cpu").Fill("")
	if v.Err() != nil {
		fmt.Println("failed to fill: ", v.Err())
	}
}

func main() {
	fill()
}

output

➜  go run main.go
failed to fill:  cpu: invalid value "" (out of bound =~"^\\d{4}$")

[verdverm]

You want to use the cue/load package

https://cuetorials.com/go-api/loading/

package main

import (
	"fmt"

	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/load"
)

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

	// The entrypoints are the same as the files you'd specify at the command line
	entrypoints := []string{"hello.cue"}

	// Load Cue files into Cue build.Instances slice
	// the second arg is a configuration object, we'll see this later
	bis := load.Instances(entrypoints, nil)

	// Loop over the instances, typically there is only one
	for _, bi := range bis {
		// check for errors on the instance
		// these are typically parsing errors
		if bi.Err != nil {
			fmt.Println("Error during load:", bi.Err)
			continue
		}

		// 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())
			continue
		}

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

		// Print the value
		fmt.Println("value:", value)
	}
}

[sahroshan]

Hi @verdverm
Thank you for the reply. I have been working on tool which validates contract between teams using cuelang.
Purpose of my tool is to partial update input cue and give out a new cue file which will be used by further systems.

I have one more small doubt why value := ctx.BuildInstance(bi) does not write import and package info in fmt.Println .

Since import "strings" is missing in output, the generated cue by mycli will not be valid.
How can I preserve package and import information? Or even use cue cli eval as an API. I believe giving these simple API would encourage many golang projects to use cue.

//hello.cue
import "strings"

hello:       "world"
mycli:       string
conditional: strings.MinRunes(1)

//main.go

package main

import (
	"fmt"

	"cuelang.org/go/cue"
	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/load"
)

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

	// The entrypoints are the same as the files you'd specify at the command line
	entrypoints := []string{"hello.cue"}

	// Load Cue files into Cue build.Instances slice
	// the second arg is a configuration object, we'll see this later
	bis := load.Instances(entrypoints, nil)

	// Loop over the instances, typically there is only one
	for _, bi := range bis {
		// check for errors on the instance
		// these are typically parsing errors
		if bi.Err != nil {
			fmt.Println("Error during load:", bi.Err)
			continue
		}

		// Use cue.Context.BuildInstance to turn
		// a build.Instance into a cue.Value
		value := ctx.BuildInstance(bi)
		value = value.FillPath(cue.ParsePath("mycli"), "cli will populate based on response of a system")
		if value.Err() != nil {
			fmt.Println("Error during build:", value.Err())
			continue
		}

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

		// Print the value
		fmt.Println("value:", value)
	}
}

➜  go run main.go
value: {
	hello:       "world"
	mycli:       "cli will populate based on response of a system"
	conditional: strings.MinRunes(1)
}

[sahroshan]

sorry
found the documentation. Instead println should use.

		syn := value.Syntax(
			cue.Final(),         // close structs and lists
			cue.Concrete(false), // allow incomplete values
			cue.Definitions(false),
			cue.Hidden(true),
			cue.Optional(true),
			cue.Attributes(true),
			cue.Docs(true),
		)

		// Pretty print the AST, returns ([]byte, error)
		bs, _ := format.Node(
			syn,
			// format.TabIndent(false),
			// format.UseSpaces(2),
		)