How to use cuecontext.Context to compile definitions and concrete values in multiple passes

[cueckoo]

Originally opened by @yannk in cuelang/cue#988

Using 0.4.0-rc.1 I'd like to load one cue file holding definitions, and then load cue instances from various sources (disk for instance). I can't find what's the right Go API to use to achieve that. I assumed that 'context' would retain the definitions already compiled.

But the second CompileString in the example below returns an bottom Value.

package main

import (
	"fmt"

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

func main() {

	ctx := cuecontext.New()

	def := ctx.CompileString(`
#Def: {
	id: string
    version: string
}`)

	val := ctx.CompileString(`
v: #Def & { id: "hi" }
	`)
	fmt.Printf("val: %!v(MISSING)\n", val)

	root := cue.Path{}
	v := def.FillPath(root, val)
	fmt.Printf("%!v(MISSING)\n", v.LookupPath(cue.ParsePath("v")))
}

outputs:

val: _|_ // 2:4: reference "#Def" not found
_|_ // field "v" not found

Of course it works when v and #Def are compiled at once.

package main

  import (
      "fmt"

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

 func main() {

      ctx := cuecontext.New()

      def := ctx.CompileString(`
  #Def: {
      id: string
      version: string
  }
  v: #Def & { id: "hi" }
      `)
      fmt.Printf("def: %!v(MISSING)\n", def)

      fmt.Printf("%!v(MISSING)\n", def.LookupPath(cue.ParsePath("v")))
  }

I'm still trying to wrap my head around how to best use Cue, since I'll import tool/exec, I was thinking about using vanilla cue scripts to load data validated against those definitions, then run processing on that validated data to finally output cue values back to storage. But I want context.Timeout that seems to be missing from tool/exec, so I ended up wanting to write a Go program to package that nicely but bumped into the problem above.

Thanks!

[cueckoo]

Original reply by @mpvl in cuelang/cue#988 (comment)

The Context does not retain anything. The context just holds indices for mapping field names, builtins, etc. But there is no retention otherwise.

However, you can pass a "scope" which is used to resolve all unresolved identifiers:

	ctx := cuecontext.New()

	def := ctx.CompileString(`
#Def: {
	id: string
    version: string
}`)

	val := ctx.CompileString(`
v: #Def & { id: "hi" }
	`, cue.Scope(def)) // USE def to RESOLVE UNRESOLVED IDENTIFIERS, LIKE #Def

[cueckoo]

Original reply by @yannk in cuelang/cue#988 (comment)

Awesome, thanks.

Do you recommend using CompileString / cue.Scope or something that seems more high-level: cue/load and friends?

Again, the goal is to load a schema once and do multiple, unrelated, data file loads that will be validated against it.

Thanks!

[cueckoo]

Original reply by @myitcv in cuelang/cue#988 (comment)

Really whatever works best for you. The only constraint you need to be aware of however is that you need to use the same cue.Context when constructing cue.Value instances.