How to validate data against schema in v0.4.0 in Go

[owulveryck]

Hello,

I wrote a couple of definition in CUE, for example:

// schema/event/event.cue
package event

// Definition of the envelop
#Envelop: {
	subject:          =~"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$" // a uuid
	source:           =~"^net.mycompany.+"
	type:             =~"^net.mycompany.+:[cud]" // c : create u : update d : delete
	version:          =~"^v.*"                   // TODO put a proper version check
	dataContentType?: string
}

// producers/sample1/definitions.cue
package sample1

import (
	"github.com/myteam/myproject/schemas/event:event"
)

#Schema: {
	envelop: event.#Envelop & {
		source:  "net.mycompany.sample1"
		version: "v1.0.0"
	}
	data: {
		// size is the size in centimeters
		size: int & <250
	}
}

// producers/sample1/sample.cue
message: #Schema & {
	envelop: {
		type:    "net.mycompany.sample1:c"
		subject: "123e4567-e89b-12d3-a456-426614174000"
	}
	data: {
		// weight is the weight in kgs
		weight: 92
	}
}

I can use cue vet definition.cue sample.cue to validate the data and it works as expected.
I'd like to do the same within a Go code.

Is there a straightforward way to do it?

[owulveryck]

Here is the solution:

package main

import (
	"log"

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

func main() {
	ctx := cuecontext.New()

	binst := load.Instances([]string{"definitions.cue", "testdata/sample.cue"}, nil)
	insts, err := ctx.BuildInstances(binst)
	if err != nil {
		log.Fatal(err)
	}
	if len(insts) != 1 {
		log.Fatal("more than one instance")
	}
	v := insts[0]
	opts := []cue.Option{
		cue.Attributes(true),
		cue.Definitions(true),
		cue.Hidden(true),
	}
	err = v.Validate(opts...)
	if err != nil {
		log.Fatal(err)
	}
}

[owulveryck]

I add one more question:

Consider the following data:

import (
	"github.com/mycorp/myproject/producers/sample1:sample1"
)

// producers/sample1/sample.cue
message: #Schema & {
	envelop: {
		type:    "net.mycompany.sample1:c"
		subject: "123e4567-e89b-12d3-a456-426614174000"
	}
	data: {
		// weight is the weight in kgs
		weight: 92
	}
}

I can validate the file without explicitly loading the definitions:

...
	binst := load.Instances([]string{ "testdata/sample.cue"}, nil)
...

I wonder now if there is a way to load the "definitions" in a context, a runtime, or whatever, so I can validate the data on the fly in a webservice for example?

edit

I tried with JSON which would do what I am trying to achieve:

package main

import (
	"io/ioutil"
	"log"

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

func main() {
	ctx := cuecontext.New()

	binst := load.Instances([]string{"definitions.cue"}, nil)
	insts, err := ctx.BuildInstances(binst)
	if err != nil {
		log.Fatal(err)
	}
	if len(insts) != 1 {
		log.Fatal("more than one instance")
	}
	v := insts[0]
	b, err := ioutil.ReadFile("testdata/bad.json")
	if err != nil {
		log.Fatal(err)
	}
	err = json.Validate(b, v)
	if err == nil {
		log.Fatal(err)

	}
}

and bad.json is:

{
    "message": {
        "envelop": {
            "topic": "net.mycompany.sample1.topic:1234",
            "subject": "123e4567-e89b-12d3-a456-426614174000",
            "type": "net.mycompany.sample1:c",
            "version": "v1.0.0"
        },
        "data": {
            "weight": 250
        }
    }
}

This should fail, but it does not :(

[owulveryck]

Self-response: the json file does not carry the type information for the message object; therefore there is no way to validate it

[owulveryck]

For the record, I managed to do what I want:

const sample = `
{
	"envelop": {
		"topic": "net.mycompany.sample1.topic:1234",
		"subject": "123e4567-e89b-12d3-a456-426614174000",
		"type": "net.mycompany.sample1:c",
		"version": "v1.0.0"
	},
	"data": {
		"weight": 250
	}
}
`

func main() {
	ctx := cuecontext.New()

	buildInstances := load.Instances([]string{"definitions.cue"}, nil)
	values, err := ctx.BuildInstances(buildInstances)
	if err != nil {
		log.Fatal(err)
	}
	if len(values) != 1 {
		log.Fatal("more than one value")
	}
	v := values[0]
	v = v.LookupPath(cue.ParsePath("#Schema"))

	b := []byte(sample)
	data := ctx.CompileBytes(b, cue.Filename("content.json"))
	unified := data.Unify(v)
	opts := []cue.Option{
		cue.Attributes(true),
		cue.Definitions(true),
		cue.Hidden(true),
	}
	err = unified.Validate(opts...)
	if err != nil {
		log.Fatal(err)
	}
}

[myitcv]

One option that we use in preguide is to embed the relevant CUE:

https://github.com/play-with-go/preguide/blob/e5ab271ba2e92313c56754702035862b357bb48d/preguide.go#L20

that then gets loaded via:

https://github.com/play-with-go/preguide/blob/e5ab271ba2e92313c56754702035862b357bb48d/preguide.go#L71

Ultimately there is a plan to fully support this kind of pattern by making support for io/fs.FS a first-class citizen:

#607 (comment)

[myitcv]

(note however that that code is using deprecated features like cue.Runtime and needs to be updated!)

[cueckoo]

This discussion has been migrated to cue-lang/cue#1030.

For more details about CUE's migration to a new home, please see cue-lang/cue#1078.