Method Verify

pkg/policies/engine/rego/rego.go:126–220

(ctx context.Context, policy *engine.Policy, input []byte, args map[string]any)

}

func (r *Engine) Verify(ctx context.Context, policy *engine.Policy, input []byte, args map[string]any) (*engine.EvaluationResult, error) {
	policyString := string(policy.Source)
	parsedModule, err := ast.ParseModule(policy.Name, policyString)
	if err != nil {
		return nil, fmt.Errorf("failed to parse rego policy: %w", err)
	}

	// Decode input as json
	decoder := json.NewDecoder(bytes.NewReader(input))
	decoder.UseNumber()
	var decodedInput interface{}
	if err := decoder.Decode(&decodedInput); err != nil {
		return nil, fmt.Errorf("failed to parse input: %w", err)
	}

	// if input is an array, transform it to an object
	if array, ok := decodedInput.([]interface{}); ok {
		inputMap := make(map[string]interface{})
		inputMap[inputElements] = array
		decodedInput = inputMap
	}

	if inputMap, ok := decodedInput.(map[string]interface{}); ok {
		decodedInput = r.injectProjectMetadata(inputMap)
	}

	// put arguments embedded in the input object
	if args != nil {
		inputMap, ok := decodedInput.(map[string]interface{})
		if !ok {
			return nil, fmt.Errorf("unexpected input arguments")
		}
		inputMap[inputArgs] = args
		decodedInput = inputMap
	}

	// add input
	regoInput := rego.Input(decodedInput)

	// add module
	regoFunc := rego.ParsedModule(parsedModule)

	var res rego.ResultSet
	// Function to execute the query with appropriate parameters
	executeQuery := func(rule string, strict bool) error {
		options := []func(r *rego.Rego){regoInput, regoFunc, rego.Capabilities(r.Capabilities())}

		// Add print support if enabled
		if r.EnablePrint {
			options = append(options,
				rego.EnablePrintStatements(true),
				rego.PrintHook(&regoOutputHook{}),
			)
		}

		if strict {
			options = append(options, rego.StrictBuiltinErrors(true))
		}