sprintf builtin

core/src/main/java/com/styra/opa/wasm/builtins/Provided.java

@@ -21,6 +21,6 @@ private static OpaBuiltin.Builtin[] merge(
     }
 
     public static OpaBuiltin.Builtin[] all() {
-        return all(Json.all(), Yaml.all());
+        return all(String.all(), Json.all(), Yaml.all());
     }
 }

core/src/main/java/com/styra/opa/wasm/builtins/String.java

@@ -0,0 +1,76 @@
+package com.styra.opa.wasm.builtins;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.TextNode;
+import com.styra.opa.wasm.OpaBuiltin;
+import com.styra.opa.wasm.OpaWasm;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+public class String {
+
+    private static JsonNode sprintfImpl(OpaWasm instance, JsonNode operand0, JsonNode operand1) {
+        // Implementation from:
+        // https://github.com/open-policy-agent/opa/blob/269a118ad9f1b5673c68e97803d722fd4e28c0a1/v1/topdown/strings.go#L525
+        // Validate the first operand as a string
+        if (!operand0.isTextual()) {
+            throw new IllegalArgumentException("Operand 1 must be a string.");
+        }
+        var format = operand0.asText();
+
+        // Validate the second operand as an array
+        if (!operand1.isArray()) {
+            throw new IllegalArgumentException("Operand 2 must be an array.");
+        }
+        var arr = new ArrayList<JsonNode>();
+        var iter = operand1.elements();
+        while (iter.hasNext()) {
+            arr.add(iter.next());
+        }
+
+        // Optimized path for "to_string" for a single integer, e.g., sprintf("%d", [x])
+        if ("%d".equals(format) && arr.size() == 1) {
+            JsonNode firstElement = arr.get(0);
+            if (firstElement.isNumber()) {
+                try {
+                    return instance.jsonMapper().readTree(firstElement.numberValue().toString());
+                } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+
+        // Convert array elements into arguments
+        List<Object> args = new ArrayList<>();
+        for (JsonNode element : arr) {
+            if (element.isInt()) {
+                args.add(element.asInt());
+            } else if (element.isBigInteger()) {
+                args.add(new BigInteger(element.asText()));
+            } else if (element.isDouble()) {
+                args.add(element.asDouble());
+            } else if (element.isTextual()) {
+                args.add(element.asText());
+            } else {
+                args.add(element.toString());
+            }
+        }
+
+        // Apply formatting using String.format
+        try {
+            var result = java.lang.String.format(format, args.toArray());
+            return TextNode.valueOf(result);
+        } catch (IllegalArgumentException e) {
+            throw new RuntimeException("Formatting error: " + e.getMessage());
+        }
+    }
+
+    public static final OpaBuiltin.Builtin sprintf =
+            OpaBuiltin.from("sprintf", String::sprintfImpl);
+
+    public static OpaBuiltin.Builtin[] all() {
+        return new OpaBuiltin.Builtin[] {sprintf};
+    }
+}

core/src/test/java/com/styra/opa/wasm/OpaStringBuiltinsTest.java

@@ -0,0 +1,49 @@
+package com.styra.opa.wasm;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.file.Path;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class OpaStringBuiltinsTest {
+    static Path wasmFile;
+
+    @BeforeAll
+    public static void beforeAll() throws Exception {
+        wasmFile =
+                OpaCli.compile(
+                                "string-builtins",
+                                "string_builtins/invoke_sprintf",
+                                "string_builtins/integer_fastpath",
+                                "string_builtins/string_example")
+                        .resolve("policy.wasm");
+    }
+
+    @Test
+    public void sprintf() {
+        var opa = OpaPolicy.builder().withPolicy(wasmFile).build();
+
+        var result = Utils.getResult(opa.entrypoint("string_builtins/invoke_sprintf").evaluate());
+
+        assertEquals("hello user your number is 321!", result.get("printed").asText());
+    }
+
+    @Test
+    public void integerFastPath() {
+        var opa = OpaPolicy.builder().withPolicy(wasmFile).build();
+
+        var result = Utils.getResult(opa.entrypoint("string_builtins/integer_fastpath").evaluate());
+
+        assertEquals(123, result.get("printed").asInt());
+    }
+
+    @Test
+    public void stringExample() {
+        var opa = OpaPolicy.builder().withPolicy(wasmFile).build();
+
+        var result = Utils.getResult(opa.entrypoint("string_builtins/string_example").evaluate());
+
+        assertEquals("my string", result.get("printed").asText());
+    }
+}

core/src/test/resources/fixtures/string-builtins/capabilities.json

@@ -0,0 +1,24 @@
+{
+  "builtins": [
+    {
+      "name": "sprintf",
+      "decl": {
+        "args": [
+          {
+            "type": "string"
+          },
+          {
+            "dynamic": {
+              "type": "any"
+            },
+            "type": "array"
+          }
+        ],
+        "result": {
+          "type": "string"
+        },
+        "type": "function"
+      }
+    }
+  ]
+}

core/src/test/resources/fixtures/string-builtins/policy.rego

@@ -0,0 +1,13 @@
+package string_builtins
+
+invoke_sprintf = x {
+   x = { "printed": sprintf("hello %s your number is %d!", ["user", 321]) }
+}
+
+integer_fastpath = x {
+   x = { "printed": sprintf("%d", [123]) }
+}
+
+string_example = x {
+   x = { "printed": sprintf("%s", ["my string"]) }
+}