🧹 remove the old min mondoo version handling

Signed-off-by: Dominik Richter <dominik.richter@gmail.com>

Author: arlimus

exec/internal/builder.go

@@ -4,14 +4,10 @@
 package internal
 
 import (
-	"fmt"
 	"math"
 	"sort"
 	"time"
 
-	vrs "github.com/hashicorp/go-version"
-	"github.com/rs/zerolog/log"
-	"go.mondoo.com/mql/v13"
 	"go.mondoo.com/mql/v13/llx"
 	"go.mondoo.com/mql/v13/providers-sdk/v1/resources"
 )
@@ -37,9 +33,6 @@ type GraphBuilder struct {
 	// progressReporter is a configured interface to receive progress
 	// updates
 	progressReporter ProgressReporter
-	// mondooVersion is the version of mondoo. This is generally sourced
-	// from the binary, but is configurable to make testing easier
-	mondooVersion string
 	// queryTimeout is the amount of time to wait for the underlying lumi
 	// runtime to send all the expected datapoints.
 	queryTimeout time.Duration
@@ -52,7 +45,6 @@ func NewBuilder() *GraphBuilder {
 		collectDatapointChecksums: []string{},
 		datapointType:             map[string]string{},
 		progressReporter:          NoopProgressReporter{},
-		mondooVersion:             mql.GetCoreVersion(),
 		queryTimeout:              5 * time.Minute,
 	}
 }
@@ -87,12 +79,7 @@ func (b *GraphBuilder) WithProgressReporter(r ProgressReporter) {
 	b.progressReporter = r
 }
 
-// WithMondooVersion sets the version of mondoo
-func (b *GraphBuilder) WithMondooVersion(mondooVersion string) {
-	b.mondooVersion = mondooVersion
-}
-
-// WithMondooVersion sets the version of mondoo
+// WithQueryTimeout sets the query timeout for the graph executor
 func (b *GraphBuilder) WithQueryTimeout(timeout time.Duration) {
 	b.queryTimeout = timeout
 }
@@ -125,24 +112,8 @@ func (b *GraphBuilder) Build(schema resources.ResourcesSchema, runtime llx.Runti
 		},
 	}
 
-	unrunnableQueries := []query{}
-
-	var mondooVersion *vrs.Version
-	if b.mondooVersion != "" && b.mondooVersion != "unstable" {
-		var err error
-		mondooVersion, err = vrs.NewVersion(b.mondooVersion)
-		if err != nil {
-			log.Warn().Err(err).Str("version", b.mondooVersion).Msg("unable to parse mondoo version")
-		}
-	}
-
 	for queryID, q := range queries {
-		canRun := checkVersion(q.codeBundle, mondooVersion)
-		if canRun {
-			ge.addExecutionQueryNode(queryID, q, q.resolvedProperties, b.datapointType)
-		} else {
-			unrunnableQueries = append(unrunnableQueries, q)
-		}
+		ge.addExecutionQueryNode(queryID, q, q.resolvedProperties, b.datapointType)
 	}
 
 	datapointsToCollect := make([]string, len(b.collectDatapointChecksums))
@@ -152,8 +123,6 @@ func (b *GraphBuilder) Build(schema resources.ResourcesSchema, runtime llx.Runti
 		ge.addEdge(NodeID(datapointChecksum), DatapointCollectorID)
 	}
 
-	ge.handleUnrunnableQueries(unrunnableQueries)
-
 	ge.createFinisherNode(b.progressReporter)
 
 	for nodeID := range ge.nodes {
@@ -169,31 +138,6 @@ func (b *GraphBuilder) Build(schema resources.ResourcesSchema, runtime llx.Runti
 	return ge, nil
 }
 
-// handleUnrunnableQueries takes the queries for which the running version does
-// to meet the minimum version requirement and marks the datapoints as error.
-// This is only done for datapoints which will not be reported by a runnable query
-func (ge *GraphExecutor) handleUnrunnableQueries(unrunnableQueries []query) {
-	for _, q := range unrunnableQueries {
-		for _, checksum := range CodepointChecksums(q.codeBundle) {
-			if _, ok := ge.nodes[NodeID(checksum)]; ok {
-				// If the datapoint will be reported by another query, skip
-				// handling it
-				continue
-			}
-
-			ge.addDatapointNode(
-				checksum,
-				nil,
-				&llx.RawResult{
-					CodeID: checksum,
-					Data: &llx.RawData{
-						Error: fmt.Errorf("unable to run query, at least mql version %s required", q.codeBundle.MinMondooVersion),
-					},
-				})
-		}
-	}
-}
-
 func (ge *GraphExecutor) addEdge(from NodeID, to NodeID) {
 	ge.edges[from] = insertSorted(ge.edges[from], to)
 }
@@ -327,17 +271,6 @@ func prioritizeNode(nodes map[NodeID]*Node, edges map[NodeID][]NodeID, priorityM
 	return myDepth
 }
 
-func checkVersion(codeBundle *llx.CodeBundle, curMin *vrs.Version) bool {
-	if curMin != nil && codeBundle.MinMondooVersion != "" {
-		requiredVer := codeBundle.MinMondooVersion
-		reqMin, err := vrs.NewVersion(requiredVer)
-		if err == nil && curMin.LessThan(reqMin) {
-			return false
-		}
-	}
-	return true
-}
-
 func insertSorted(ss []string, s string) []string {
 	i := sort.SearchStrings(ss, s)
 	if i < len(ss) && ss[i] == s {

exec/internal/builder_test.go

@@ -145,11 +145,8 @@ func TestBuilder(t *testing.T) {
 				}},
 				Checksums: map[uint64]string{1: "checksum5", 2: "checksum7"},
 			},
-			MinMondooVersion: "9999.9999.9999",
 		}, nil, nil)
 
-	b.WithMondooVersion("100.0.0")
-
 	ge, err := b.Build(nil, nil, "assetMrn")
 	require.NoError(t, err)
 
@@ -168,11 +165,8 @@ func TestBuilder(t *testing.T) {
 	hasNode(t, ge, "execution_query/query4", ExecutionQueryNodeType)
 	hasOutEdges(t, ge, "execution_query/query4", "checksum6")
 
-	assert.NotContains(t, ge.nodes, "execution_query/query5")
-	assert.Nil(t, ge.nodes["checksum5"].data.(*DatapointNodeData).res)
-	if assert.NotNil(t, ge.nodes["checksum7"].data.(*DatapointNodeData).res) {
-		assert.Error(t, ge.nodes["checksum7"].data.(*DatapointNodeData).res.Data.Error)
-	}
+	hasNode(t, ge, "execution_query/query5", ExecutionQueryNodeType)
+	hasOutEdges(t, ge, "execution_query/query5", "checksum5", "checksum7")
 
 	hasNode(t, ge, "pqep", DatapointNodeType)
 	hasOutEdges(t, ge, "pqep", CollectionFinisherID)
@@ -194,6 +188,9 @@ func TestBuilder(t *testing.T) {
 
 	hasNode(t, ge, "checksum6", DatapointNodeType)
 	hasOutEdges(t, ge, "checksum6", CollectionFinisherID)
+
+	hasNode(t, ge, "checksum7", DatapointNodeType)
+	hasOutEdges(t, ge, "checksum7", CollectionFinisherID)
 }
 
 func hasNode(t *testing.T, ge *GraphExecutor, nodeID NodeID, nodeType NodeType) {

go.mod

@@ -53,7 +53,6 @@ require (
 	github.com/hashicorp/go-hclog v1.6.3
 	github.com/hashicorp/go-plugin v1.7.0
 	github.com/hashicorp/go-retryablehttp v0.7.8
-	github.com/hashicorp/go-version v1.8.0
 	github.com/hashicorp/vault/api v1.22.0
 	github.com/hnakamur/go-scp v1.0.2
 	github.com/hokaccha/go-prettyjson v0.0.0-20211117102719-0474bc63780f

go.sum

@@ -556,8 +556,6 @@ github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/b
 github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8=
 github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-version v1.8.0 h1:KAkNb1HAiZd1ukkxDFGmokVZe1Xy9HG6NUp+bPle2i4=
-github.com/hashicorp/go-version v1.8.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=

mqlc/mqlc.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/hashicorp/go-version"
 	"github.com/lithammer/fuzzysearch/fuzzy"
 	"github.com/rs/zerolog/log"
 	"go.mondoo.com/mql/v13"
@@ -960,8 +959,6 @@ func (c *compiler) compileBoundIdentifierWithMqlCtx(id string, binding *variable
 				return true, types.Nil, errors.New("cannot call resource field with arguments yet")
 			}
 
-			c.Result.MinMondooVersion = getMinMondooVersion(c.Schema, c.Result.MinMondooVersion, resource.Name, id)
-
 			// this only happens when we call a field of a bridging resource,
 			// in which case we don't call the field (since there is nothing to do)
 			// and instead we call the resource directly:
@@ -1060,8 +1057,6 @@ func (c *compiler) compileResource(id string, calls []*parser.Call) (bool, []*pa
 		calls = calls[1:]
 	}
 
-	c.Result.MinMondooVersion = getMinMondooVersion(c.Schema, c.Result.MinMondooVersion, id, "")
-
 	typ, err := c.addResource(id, resource, call)
 	return true, calls, typ, err
 }
@@ -2138,35 +2133,6 @@ func (c *compiler) failIfNoEntrypoints() error {
 	return nil
 }
 
-func getMinMondooVersion(schema resources.ResourcesSchema, current string, resource string, field string) string {
-	info := schema.Lookup(resource)
-	if info == nil {
-		return current
-	}
-
-	min := info.MinMondooVersion
-	if field != "" {
-		if finfo, ok := info.Fields[field]; ok && finfo.MinMondooVersion != "" {
-			min = finfo.MinMondooVersion
-		}
-	}
-
-	if current == "" {
-		return min
-	} else if min == "" {
-		return current
-	}
-
-	vMin, err1 := version.NewVersion(min)
-	vCur, err2 := version.NewVersion(current)
-	// if the current version requirement is higher than docs, we keep it,
-	// otherwise docs wins
-	if err1 == nil && err2 == nil && vMin.LessThan(vCur) {
-		return current
-	}
-	return min
-}
-
 // CompileAST with a schema into a chunky code
 func CompileAST(ast *parser.AST, props PropsHandler, conf CompilerConfig) (*llx.CodeBundle, error) {
 	if conf.Schema == nil {
@@ -2186,11 +2152,10 @@ func CompileAST(ast *parser.AST, props PropsHandler, conf CompilerConfig) (*llx.
 		Labels: &llx.Labels{
 			Labels: map[string]string{},
 		},
-		Props:            map[string]string{},
-		Version:          mql.APIVersion(),
-		MinMondooVersion: "",
-		AutoExpand:       map[string]uint64{},
-		Vars:             map[uint64]string{},
+		Props:      map[string]string{},
+		Version:    mql.APIVersion(),
+		AutoExpand: map[string]uint64{},
+		Vars:       map[uint64]string{},
 	}
 
 	c := compiler{

mqlc/mqlc_test.go

@@ -1248,18 +1248,6 @@ func TestCompiler_Resource(t *testing.T) {
 	})
 }
 
-func TestCompiler_Resource_versioning(t *testing.T) {
-	compileT(t, "sshd", func(res *llx.CodeBundle) {
-		assert.Equal(t, "5.15.0", res.MinMondooVersion)
-	})
-}
-
-func TestCompiler_Resource_versioning2(t *testing.T) {
-	compileT(t, "file.empty", func(res *llx.CodeBundle) {
-		assert.Equal(t, "5.18.0", res.MinMondooVersion)
-	})
-}
-
 func TestCompiler_ResourceWithCall(t *testing.T) {
 	compileT(t, "sshd()", func(res *llx.CodeBundle) {
 		assertFunction(t, "sshd", nil, res.CodeV2.Blocks[0].Chunks[0])
@@ -1275,7 +1263,6 @@ func TestCompiler_LongResource(t *testing.T) {
 func TestCompiler_ResourceMap(t *testing.T) {
 	compileT(t, "sshd.config.params", func(res *llx.CodeBundle) {
 		assertFunction(t, "sshd.config", nil, res.CodeV2.Blocks[0].Chunks[0])
-		assert.Equal(t, "5.15.0", res.MinMondooVersion)
 		assertFunction(t, "params", &llx.Function{
 			Type:    string(types.Map(types.String, types.String)),
 			Binding: (1 << 32) | 1,

providers-sdk/v1/mqlr/lrcore/versions.go

@@ -72,8 +72,9 @@ func WriteVersions(path string, versions LrVersions, headerTpl *template.Templat
 }
 
 // InjectVersions sets MinProviderVersion on resources and fields in the schema
-// based on the versions map. Every field is expected to have an explicit entry;
-// fields without one are left empty.
+// based on the versions map. Fields whose version matches the parent resource
+// are left empty (omitted from JSON via omitempty), since consumers treat an
+// unset field version as equal to the resource version.
 func InjectVersions(schema *resources.Schema, versions LrVersions) {
 	// Build a sorted list of resource names (longest first) so we can
 	// disambiguate field paths like "aws.ec2.instance.tags" where the resource
@@ -86,20 +87,26 @@ func InjectVersions(schema *resources.Schema, versions LrVersions) {
 		return len(resourceNames[i]) > len(resourceNames[j])
 	})
 
+	// First pass: set resource versions so we can compare against them.
 	for path, version := range versions {
-		// First check if path is a resource name directly
 		if info, ok := schema.Resources[path]; ok {
 			info.MinProviderVersion = version
-			continue
 		}
+	}
 
-		// Otherwise try to split into resource + field using longest-prefix match
+	// Second pass: set field versions, skipping those that match the resource.
+	for path, version := range versions {
+		if _, isResource := schema.Resources[path]; isResource {
+			continue
+		}
 		for _, rName := range resourceNames {
 			if strings.HasPrefix(path, rName+".") {
 				fieldName := path[len(rName)+1:]
 				info := schema.Resources[rName]
 				if finfo, ok := info.Fields[fieldName]; ok {
-					finfo.MinProviderVersion = version
+					if version != info.MinProviderVersion {
+						finfo.MinProviderVersion = version
+					}
 				}
 				break
 			}

providers-sdk/v1/mqlr/lrcore/versions_test.go

@@ -116,8 +116,11 @@ func TestInjectVersions(t *testing.T) {
 	InjectVersions(schema, versions)
 
 	assert.Equal(t, "9.0.0", schema.Resources["asset"].MinProviderVersion)
+	// annotations (10.4.0) differs from asset (9.0.0) — set explicitly
 	assert.Equal(t, "10.4.0", schema.Resources["asset"].Fields["annotations"].MinProviderVersion)
-	assert.Equal(t, "9.0.0", schema.Resources["asset"].Fields["name"].MinProviderVersion)
+	// name (9.0.0) matches asset (9.0.0) — left empty (omitted from JSON)
+	assert.Equal(t, "", schema.Resources["asset"].Fields["name"].MinProviderVersion)
 	assert.Equal(t, "9.1.1", schema.Resources["asset.eol"].MinProviderVersion)
-	assert.Equal(t, "9.1.1", schema.Resources["asset.eol"].Fields["date"].MinProviderVersion)
+	// date (9.1.1) matches asset.eol (9.1.1) — left empty
+	assert.Equal(t, "", schema.Resources["asset.eol"].Fields["date"].MinProviderVersion)
 }

providers-sdk/v1/resources/schema.go

@@ -51,9 +51,6 @@ func (s *Schema) Add(other ResourcesSchema) ResourcesSchema {
 			if v.Name != "" {
 				existing.Name = v.Name
 			}
-			if v.MinMondooVersion != "" {
-				existing.MinMondooVersion = v.MinMondooVersion
-			}
 			if v.Desc != "" {
 				existing.Desc = v.Desc
 			}
@@ -81,19 +78,18 @@ func (s *Schema) Add(other ResourcesSchema) ResourcesSchema {
 			}
 		} else {
 			ri := &ResourceInfo{
-				Id:               v.Id,
-				Name:             v.Name,
-				Fields:           make(map[string]*Field, len(v.Fields)),
-				Init:             v.Init,
-				ListType:         v.ListType,
-				Title:            v.Title,
-				Desc:             v.Desc,
-				Private:          v.Private,
-				IsExtension:      v.IsExtension,
-				MinMondooVersion: v.MinMondooVersion,
-				Defaults:         v.Defaults,
-				Context:          v.Context,
-				Provider:         v.Provider,
+				Id:          v.Id,
+				Name:        v.Name,
+				Fields:      make(map[string]*Field, len(v.Fields)),
+				Init:        v.Init,
+				ListType:    v.ListType,
+				Title:       v.Title,
+				Desc:        v.Desc,
+				Private:     v.Private,
+				IsExtension: v.IsExtension,
+				Defaults:    v.Defaults,
+				Context:     v.Context,
+				Provider:    v.Provider,
 			}
 			for k, v := range v.Fields {
 				ri.Fields[k] = v