engine

var DefaultVulnerabilityBuilder = func(ctx context.Context, qCtx *QueryContext,
	tracker Tracker,
	v interface{},
	detector *dec.DetectLine,
	useOldSeverities bool,
	queryDuration time.Duration) (*model.Vulnerability, error) {
	contextLogger := logger.FromContext(ctx)
	vObj, ok := v.(map[string]interface{})
	if !ok {
		return &model.Vulnerability{}, ErrInvalidResult
	}

	vObj = mergeWithMetadata(vObj, qCtx.Query.Metadata.Metadata)

	var err error
	var output []byte

	output, err = json.Marshal(vObj)
	if err != nil {
		return &model.Vulnerability{}, errors.Wrap(err, "failed to marshall query output")
	}

	var fileID *string

	fileID, err = mapKeyToString(ctx, vObj, "documentId", false)
	if err != nil {
		return &model.Vulnerability{}, errors.Wrap(err, "failed to recognize file id")
	}

	file, ok := qCtx.Files[*fileID]
	if !ok {
		return &model.Vulnerability{}, errors.New("failed to find file from query response")
	}

	logWithFields := contextLogger.With().
		Str("scanID", qCtx.scanID).
		Str("fileName", file.FilePath).
		Str("queryName", qCtx.Query.Metadata.Query).
		Logger()

	if err := file.EnsureLineInfoDocument(ctx); err != nil {
		logWithFields.Err(err).Msg("failed to build line-info document for file")
		tracker.FailedLineInfoDocument()
	}

	linesVulne := model.VulnerabilityLines{
		Line:                  -1,
		VulnLines:             &[]model.CodeLine{},
		LineWithVulnerability: "",
	}

	searchKey := ""
	if s, ok := vObj["searchKey"]; ok {
		searchKey = s.(string)
		intDoc := file.LineInfoDocument
		vulsSplit := strings.Split(searchKey, ".")

		if file.Kind == model.KindINI {
			vulsSplit, searchKey = sanitizeINIKey(vulsSplit)
		}

		if strings.Contains(vulsSplit[len(vulsSplit)-1], "RefMetadata") {
			return &model.Vulnerability{}, ErrNoResult
		}

		searchKey, _ = modifyVulSearchKeyReference(intDoc, searchKey, vulsSplit)
		vObj["searchKey"] = searchKey
		linesVulne = detector.DetectLine(ctx, file, searchKey)
	} else {
		logWithFields.Error().Msg("Saving result. failed to detect line")
	}

	lineNumber := 0

	if !slices.Contains([]model.FileKind{model.KindHELM, model.KindTerraform}, file.Kind) && len(file.ResolvedFiles) == 0 {
		searchLineCalc := &searchLineCalculator{
			lineNr:     -1,
			vObj:       vObj,
			file:       file,
			detector:   detector,
			linesVulne: linesVulne,
		}

		lineNumber, linesVulne = calculeSearchLine(ctx, searchLineCalc)
	}

	if linesVulne.Line == -1 {
		logWithFields.Warn().Msgf("Failed to detect line, query response %s", searchKey)
		linesVulne.Line = 1
	}

	searchValue := ""
	if s, ok := vObj["searchValue"]; ok {
		searchValue = s.(string)
	}

	overrideKey := ""
	if s, ok := vObj["overrideKey"]; ok {
		overrideKey = s.(string)
	}

	platform := getStringFromMap(ctx, "platform", "", overrideKey, vObj, &logWithFields)
	resourceType := PtrStringToString(mustMapKeyToString(ctx, vObj, "resourceType"))
	if strings.EqualFold(platform, "ansible") {
		resourceType = utils.NormalizeAnsibleResourceType(resourceType)
	}

	queryID := getStringFromMap(ctx, "id", DefaultQueryID, overrideKey, vObj, &logWithFields)
	legacyQueryID := getOptionalStringKey(ctx, "legacyId", DefaultQueryID, overrideKey, vObj, &logWithFields)

	severity := getResolvedSeverity(ctx, vObj, &logWithFields, overrideKey, useOldSeverities)

	return &model.Vulnerability{
		ID:            0,
		ScanID:        qCtx.scanID,
		FileID:        file.ID,
		FileName:      linesVulne.ResolvedFile,
		QueryName:     getStringFromMap(ctx, "queryName", DefaultQueryName, overrideKey, vObj, &logWithFields),
		QueryID:       queryID,
		LegacyQueryID: legacyQueryID,
		Experimental:  getBoolFromMap(ctx, "experimental", DefaultExperimental, overrideKey, vObj, &logWithFields),
		QueryURI:      getStringFromMap(ctx, "descriptionUrl", DefaultQueryURI, overrideKey, vObj, &logWithFields),
		Category:      getStringFromMap(ctx, "category", "", overrideKey, vObj, &logWithFields),
		Description:   getStringFromMap(ctx, "descriptionText", "", overrideKey, vObj, &logWithFields),
		DescriptionID: getStringFromMap(ctx, "descriptionID", DefaultQueryDescriptionID, overrideKey, vObj, &logWithFields),
		Severity:      severity,
		Platform:      platform,
		CWE:           getStringFromMap(ctx, "cwe", "", overrideKey, vObj, &logWithFields),
		Line:          linesVulne.Line,
		VulnerabilityLocation: model.ResourceLocation{
			Start: linesVulne.VulnerablilityLocation.Start,
			End:   linesVulne.VulnerablilityLocation.End,
		},
		RemediationLocation: model.ResourceLocation{
			Start: linesVulne.RemediationLocation.Start,
			End:   linesVulne.RemediationLocation.End,
		},
		VulnLines:             linesVulne.VulnLines,
		ResourceType:          resourceType,
		ResourceName:          PtrStringToString(mustMapKeyToString(ctx, vObj, "resourceName")),
		SearchKey:             searchKey,
		SearchLine:            lineNumber,
		SearchValue:           searchValue,
		Value:                 mustMapKeyToString(ctx, vObj, "value"),
		Output:                string(output),
		CloudProvider:         getOptionalStringKey(ctx, "cloudProvider", "", overrideKey, vObj, &logWithFields),
		Remediation:           PtrStringToString(mustMapKeyToString(ctx, vObj, "remediation")),
		RemediationType:       PtrStringToString(mustMapKeyToString(ctx, vObj, "remediationType")),
		QueryDuration:         queryDuration,
		LineWithVulnerability: linesVulne.LineWithVulnerability,
		ResourceSource:        linesVulne.ResourceSource,
		FileSource:            linesVulne.FileSource,
		BlockLocation:         linesVulne.BlockLocation,
		ModuleCallChain:       file.ModuleCallChain,
		Frameworks: append(extractDefaultFrameworks(ctx, qCtx.Query.Metadata.Metadata, qCtx.FlagEvaluator),
			extractCustomFrameworks(ctx, qCtx.Query.Metadata.Metadata, qCtx.FlagEvaluator)...),
	}, nil
}

var ErrInvalidResult = errors.New("query: invalid result format")

var ErrNoResult = errors.New("query: not result")