Invalidating the InterQueryCache?

[alex-lange]

Hi,

I am hoping to use something like the InterQueryCache in some BuiltIn functions, and I'm curious if that cache gets reset/invalidated when new data is pulled from a bundle?

I would like to cache an object that is generated from data within an OPA bundle, but I'd like this object to be removed if the data in the bundle is updated (or more generally whenever a new version of a bundle is downloaded).

Thanks!
Alex

[anderseknert]

That's an interesting use case :)

While the built-in functions have access to the InterQueryCache, I don't think there's currently any way to hook into update events from the bundle plugin 🤔 To answer your other question though — no, the cache is not cleared when data is updated from bundles. Could you expand a bit more on the use case? The data fetched from bundles is by definition "cached" already.. If you want to check whether some attribute is present in the data, you could do so outside of the function call in your policy and pass that data to your custom built-in.. something like:

foo := object.get(data, "foo", "") # default to empty string if "foo" is not in data

ret := my_custom_builtin(foo)

Your function could then act depending on whether the the foo attribute was present in data, or whatever value it might have (which you could track over time to check for changes). Whether this is a viable option is hard to tell without knowing more about the details.

[alex-lange]

@anderseknert interesting!

My use-case is maybe slightly esoteric because it involves GraphQL, but I think the general idea is straightforward -- We store GraphQL schema strings as JSON in the OPA bundles. In a custom builtin function, the schema strings are passed in, and we parse/convert them into graphql-go Schema objects. We do this on every request, even though the schema strings do not update that frequently. I was wondering if there was a way to essentially store these Schema objects in the data/cache itself, so that we only do the parsing/converting when the strings are updated.

[anderseknert]

Right.. yeah, if we rule out update events for the time being, I suppose you could pass the schema to the built-in and use a hash of that as the key in the InterQueryCache to know whether it's been parsed already. This is very much untested, but something like

type schemaCacheValue struct {
	// Your schema here
}

func (s schemaCacheValue) SizeInBytes() int64 {
	return 0 // probably want to do something smarter here :)
}

func main() {

	rego.RegisterBuiltin2(
		&rego.Function{
			Name:    "my_schema_builtin",
			Decl:    types.NewFunction(types.Args(types.S, types.S), types.A),
			Memoize: true,
		},
		func(bctx rego.BuiltinContext, a, b *ast.Term) (*ast.Term, error) {
			// if key is not found in cache, create schema and insert in cache
			bctx.InterQueryBuiltinCache.Insert(ast.Value(ast.String("hashed_key")), schemaCacheValue{})
			
			// else, retrieve schema from cache