Better conversion of queries

internal/jennies/golang/rawtypes.go

@@ -60,7 +60,7 @@ func (jenny RawTypes) generateSchema(context languages.Context, schema *ast.Sche
 	equalityMethodsGenerator := newEqualityMethods(jenny.Tmpl)
 
 	schema.Objects.Iterate(func(_ string, object ast.Object) {
-		objectOutput, innerErr := jenny.formatObject(object)
+		objectOutput, innerErr := jenny.formatObject(schema, object)
 		if innerErr != nil {
 			err = innerErr
 			return
@@ -99,7 +99,7 @@ func (jenny RawTypes) generateSchema(context languages.Context, schema *ast.Sche
 %[2]s%[3]s`, formatPackageName(schema.Package), importStatements, buffer.String())), nil
 }
 
-func (jenny RawTypes) formatObject(def ast.Object) ([]byte, error) {
+func (jenny RawTypes) formatObject(schema *ast.Schema, def ast.Object) ([]byte, error) {
 	var buffer strings.Builder
 
 	defName := tools.UpperCamelCase(def.Name)
@@ -145,6 +145,12 @@ func (jenny RawTypes) formatObject(def ast.Object) ([]byte, error) {
 
 		buffer.WriteString(fmt.Sprintf("func (resource %s) Implements%sVariant() {}\n", defName, variant))
 		buffer.WriteString("\n")
+
+		if def.Type.ImplementedVariant() == string(ast.SchemaVariantDataQuery) {
+			buffer.WriteString(fmt.Sprintf("func (resource %s) DataqueryType() string {\n", defName))
+			buffer.WriteString(fmt.Sprintf("\treturn \"%s\"\n", strings.ToLower(schema.Metadata.Identifier)))
+			buffer.WriteString("}\n")
+		}
 	}
 
 	return []byte(buffer.String()), nil

internal/jennies/golang/templates/runtime/runtime.tmpl

@@ -111,7 +111,6 @@ func ConfigForPanelcfgVariant(identifier string) (variants.PanelcfgConfig, bool)
 	return NewRuntime().ConfigForPanelcfgVariant(identifier)
 }
 
-
 func (runtime *Runtime) ConvertPanelToGo(inputPanel any, panelType string) string {
 	config, found := runtime.panelcfgVariants[panelType]
 	if found && config.GoConverter != nil {
@@ -121,12 +120,10 @@ func (runtime *Runtime) ConvertPanelToGo(inputPanel any, panelType string) strin
 	return "/* could not convert panel to go */"
 }
 
-func (runtime *Runtime) ConvertDataqueryToGo(inputPanel any, dataqueryTypeHints ...string) string {
-	for _, dataqueryTypeHint := range dataqueryTypeHints {
-		config, found := runtime.dataqueryVariants[dataqueryTypeHint]
-		if found && config.GoConverter != nil {
-			return config.GoConverter(inputPanel)
-		}
+func (runtime *Runtime) ConvertDataqueryToGo(dataquery variants.Dataquery) string {
+	config, found := runtime.dataqueryVariants[dataquery.DataqueryType()]
+	if found && config.GoConverter != nil {
+		return config.GoConverter(dataquery)
 	}
 
 	return "/* could not convert dataquery to go */"
@@ -136,8 +133,8 @@ func ConvertPanelToCode(inputPanel any, panelType string) string {
 	return NewRuntime().ConvertPanelToGo(inputPanel, panelType)
 }
 
-func ConvertDataqueryToCode(inputPanel any, dataqueryTypeHints ...string) string {
-	return NewRuntime().ConvertDataqueryToGo(inputPanel, dataqueryTypeHints...)
+func ConvertDataqueryToCode(dataquery variants.Dataquery) string {
+	return NewRuntime().ConvertDataqueryToGo(dataquery)
 }
 
 func Dump(root any) string {

internal/jennies/golang/templates/runtime/variant_models.tmpl

@@ -16,6 +16,7 @@ type DataqueryConfig struct {
 type Dataquery interface {
 	ImplementsDataqueryVariant()
 	Equals(other Dataquery) bool
+	DataqueryType() string
 }
 
 type Panelcfg interface {
@@ -24,10 +25,12 @@ type Panelcfg interface {
 
 type UnknownDataquery map[string]any
 
-func (unknown UnknownDataquery) ImplementsDataqueryVariant() {
-
+func (unknown UnknownDataquery) DataqueryType() string {
+	return "unknown"
 }
 
+func (unknown UnknownDataquery) ImplementsDataqueryVariant() { }
+
 func (unknown UnknownDataquery) Equals(otherCandidate Dataquery) bool {
 	if otherCandidate == nil {
 		return false

internal/languages/converter.go

@@ -284,42 +284,13 @@ func (generator *ConverterGenerator) argumentsForEnvelope(context Context, conve
 
 func (generator *ConverterGenerator) argumentForType(context Context, converter Converter, argName string, valuePath ast.Path, typeDef ast.Type) ArgumentMapping {
 	if typeDef.IsComposableSlot() {
-		var slotTypeHintsArgs []*DirectArgMapping
-		var guards []MappingGuard
-		converterRootType := context.ResolveRefs(converter.inputRootPath().Last().Type)
-
-		if converterRootType.IsStruct() {
-			for _, field := range converterRootType.Struct.Fields {
-				if !field.Type.IsRef() || field.Type.AsRef().ReferredType != "DataSourceRef" {
-					continue
-				}
-
-				refPath := ast.PathFromStructField(field)
-				datasourceRefType := context.ResolveRefs(field.Type)
-
-				typeField, found := datasourceRefType.Struct.FieldByName("type")
-				if !found {
-					continue
-				}
-
-				typePath := refPath.AppendStructField(typeField)
-				guards = append(guards, generator.pathNotNullGuards(converter, typePath)...)
-
-				slotTypeHintsArgs = append(slotTypeHintsArgs, &DirectArgMapping{
-					ValuePath: converter.inputRootPath().Append(typePath),
-					ValueType: typeField.Type,
-				})
-			}
-		}
-
 		return ArgumentMapping{
 			Runtime: &RuntimeArgMapping{
 				FuncName: fmt.Sprintf("Convert%sToCode", tools.UpperCamelCase(string(typeDef.AsComposableSlot().Variant))),
-				Args: append([]*DirectArgMapping{
+				Args: []*DirectArgMapping{
 					{ValuePath: valuePath, ValueType: typeDef},
-				}, slotTypeHintsArgs...),
+				},
 			},
-			Guards: guards,
 		}
 	}
 

testdata/jennies/rawtypes/variant_dataquery/GoRawTypes/variant_dataquery/types_gen.go

@@ -10,6 +10,9 @@ type Query struct {
 }
 func (resource Query) ImplementsDataqueryVariant() {}
 
+func (resource Query) DataqueryType() string {
+	return "prometheus"
+}
 
 func VariantConfig() variants.DataqueryConfig {
 	return variants.DataqueryConfig{