Tag Injection Across Modules

[GreeshmaKaranth]

Hello,

I have a module with a bunch of packages that I import and use across files. I want to specify tags in one file and be able to inject the tags from another file. However, this seems to be impossible so I wanted to post here asking for suggestions!

library.cue

package library

#key: *"value" | string @tag(injectedValue)

main.cue

import example.com/sample:library

library.#key

This command works, as expected

cue export library.cue --inject injectedValue=newvalue

>>> "newvalue"

I want to be able to call this from the command line as so:

cue export main.cue --inject injectedValue=newvalue

But this returns with the following error: no tag for "injectedValue"

Is there any way I can get this to work? Any help would be deeply appreciated thank you!

[WaywardWizard]

i tried;

'''
cue export :foo -t foovar=bar :bar -t barvar=tar
'''

this will output both packages, but the injection isnt working like you would think and foovar is not defined in :foo

[verdverm]

I don't believe this is currently possible

1. The tag injection walks the AST, which is before the evaluator and the ADT is built (at which point the actual import contents are processed iirc) The actual code is here: https://github.com/cue-lang/cue/blob/master/cue/load/tags.go#L238 and you could print the instance files (b.Files) to see what it sees for clarity
2. iirc, this would modify the value in another package, which I believe will eventually be closed (not yet enforced)

tl;dr tag injection is part of the cue CLI, more than it is an aspect of the language (not in the spec), and lives outside of / before the evaluator

Another thing to consider, what would happen if you use a tag and one of the 3rd party modules you import has the same tag, but expects a different kind of value. Thus it makes sense to only process tags at the top-level (entrypoint package) and ignore others. Typically and generally speaking, libraries don't expose flags directly, but may give you a handle to expose them in your own applications.

You should be define the flags and then expose them like so

-- library.cue --
package library

#flags: {
  foo: string @tag(foo)
}

#thing: {
  flags: #flags

  bar: *flags.foo | "bar"  
}

-- main.cue --
package main

import "foo.com/library"

myflags: library.#flags

thing: library.#thing & { flags: myflags }

[Liimurr]

I don't think there is a satisfying workaround for conditional building based on flags right now. e.g.

-- library.cue --
package library

#thing : {
  bar : string
}

-- library_cpp.cue --
@if(foo)

package library

#thing : {
  bar : "foo"
}

-- main.cue --
package main

import "foo.com/library"

thing: library.#thing