Initial draft of Regorus extension to invoke C# code

Author: kusha

.gitignore

@@ -14,6 +14,9 @@ Cargo.lock
 # vscode files
 .vscode/
 
+# vs files 
+.vs/
+
 # worktrees
 worktrees/
 

bindings/csharp/Regorus/Regorus.cs

@@ -4,18 +4,41 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Collections.Generic;
+using System.Text.Json;
 
 
 #nullable enable
 namespace Regorus
 {
+    /// <summary>
+    /// Delegate for callback functions that can be invoked from Rego policies
+    /// </summary>
+    /// <param name="payload">Deserialized JSON object containing the payload from Rego</param>
+    /// <returns>Object that will be serialized to JSON and converted to a Rego value</returns>
+    public delegate object RegoCallback(object payload);
+    
     public unsafe sealed class Engine : System.IDisposable
     {
         private Regorus.Internal.RegorusEngine* E;
         // Detect redundant Dispose() calls in a thread-safe manner.
         // _isDisposed == 0 means Dispose(bool) has not been called yet.
         // _isDisposed == 1 means Dispose(bool) has been already called.
         private int isDisposed;
+        
+        // Store callback delegates to prevent garbage collection
+        private readonly Dictionary<string, (Internal.RegorusCallbackDelegate Delegate, GCHandle Handle)> callbackDelegates 
+            = new Dictionary<string, (Internal.RegorusCallbackDelegate, GCHandle)>();
+        
+        // Store user callbacks
+        private readonly Dictionary<string, RegoCallback> callbacks = new Dictionary<string, RegoCallback>();
+
+        // JSON serialization options
+        private static readonly JsonSerializerOptions JsonOptions = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            WriteIndented = false
+        };
 
         public Engine()
         {
@@ -51,7 +74,11 @@ void Dispose(bool disposing)
                 // and unmanaged resources.
                 if (disposing)
                 {
-                    // No managed resource to dispose.
+                    // Unregister all callbacks
+                    foreach (var name in new List<string>(callbackDelegates.Keys))
+                    {
+                        UnregisterCallback(name);
+                    }
                 }
 
                 // Call the appropriate methods to clean up
@@ -202,7 +229,139 @@ public void SetGatherPrints(bool enable)
             return CheckAndDropResult(Regorus.Internal.API.regorus_engine_take_prints(E));
         }
 
-
+        // Generic callback handler that routes to the appropriate user-provided callback
+        private static unsafe byte* CallbackHandler(byte* payloadPtr, void* contextPtr)
+        {
+            try
+            {
+                // Context pointer contains the engine instance and callback name
+                var context = GCHandle.FromIntPtr(new IntPtr(contextPtr));
+                var contextData = (CallbackContext)context.Target!;
+                
+                if (contextData == null || contextData.Engine == null)
+                {
+                    return null;
+                }
+                
+                // Convert the payload to a string
+                var payload = Marshal.PtrToStringUTF8(new IntPtr(payloadPtr));
+                if (payload == null)
+                {
+                    return null;
+                }
+                
+                // Deserialize the payload to an object
+                var payloadObject = JsonSerializer.Deserialize<object>(payload, JsonOptions);
+                if (payloadObject == null)
+                {
+                    return null;
+                }
+                
+                // Get the user callback
+                if (!contextData.Engine.callbacks.TryGetValue(contextData.CallbackName, out var callback))
+                {
+                    return null;
+                }
+                
+                // Call the user callback
+                var result = callback(payloadObject);
+                
+                if (result == null)
+                {
+                    return null;
+                }
+                
+                // Always serialize the result to JSON, even if it's a string
+                string jsonResult = JsonSerializer.Serialize(result, JsonOptions);
+                
+                // Convert the result back to a C string that Rust will free
+                return (byte*)Marshal.StringToCoTaskMemUTF8(jsonResult).ToPointer();
+            }
+            catch
+            {
+                return null;
+            }
+        }
+        
+        private class CallbackContext
+        {
+            public Engine Engine { get; set; }
+            public string CallbackName { get; set; }
+            
+            public CallbackContext(Engine engine, string name)
+            {
+                Engine = engine;
+                CallbackName = name;
+            }
+        }
+        
+        /// <summary>
+        /// Register a callback function that can be invoked from Rego policies
+        /// </summary>
+        /// <param name="name">Name of the callback function to register</param>
+        /// <param name="callback">Callback function to be invoked</param>
+        /// <returns>True if registration succeeded, otherwise false</returns>
+        public bool RegisterCallback(string name, RegoCallback callback)
+        {
+            if (string.IsNullOrEmpty(name) || callback == null)
+            {
+                return false;
+            }
+            
+            // Store the callback in our dictionary
+            callbacks[name] = callback;
+            
+            // Create a context object and GCHandle
+            var contextData = new CallbackContext(this, name);
+            var contextHandle = GCHandle.Alloc(contextData);
+            var contextPtr = GCHandle.ToIntPtr(contextHandle);
+            
+            // Create a delegate for the callback handler
+            var callbackDelegate = new Internal.RegorusCallbackDelegate(CallbackHandler);
+            
+            // Store the delegate to prevent garbage collection
+            callbackDelegates[name] = (callbackDelegate, contextHandle);
+            
+            // Register the callback with the native code
+            var nameBytes = NullTerminatedUTF8Bytes(name);
+            fixed (byte* namePtr = nameBytes)
+            {
+                var result = Internal.API.regorus_register_callback(namePtr, callbackDelegate, (void*)contextPtr);
+                return result == Internal.RegorusStatus.RegorusStatusOk;
+            }
+        }
+        
+        /// <summary>
+        /// Unregister a previously registered callback function
+        /// </summary>
+        /// <param name="name">Name of the callback function to unregister</param>
+        /// <returns>True if unregistration succeeded, otherwise false</returns>
+        public bool UnregisterCallback(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+            {
+                return false;
+            }
+            
+            // Remove the callback from our dictionary
+            callbacks.Remove(name);
+            
+            // Unregister the callback from the native code
+            var nameBytes = NullTerminatedUTF8Bytes(name);
+            fixed (byte* namePtr = nameBytes)
+            {
+                var result = Internal.API.regorus_unregister_callback(namePtr);
+                
+                // Free the GCHandle if we have it
+                if (callbackDelegates.TryGetValue(name, out var delegateInfo))
+                {
+                    delegateInfo.Handle.Free();
+                    callbackDelegates.Remove(name);
+                }
+                
+                return result == Internal.RegorusStatus.RegorusStatusOk;
+            }
+        }
 
         string? StringFromUTF8(IntPtr ptr)
         {

bindings/csharp/Regorus/Regorus.csproj

@@ -10,6 +10,10 @@
         <PackageReadmeFile>README.md</PackageReadmeFile>
     </PropertyGroup>
 
+    <ItemGroup>
+        <PackageReference Include="System.Text.Json" Version="9.0.4" />
+    </ItemGroup>
+
     <!--
         $(RegorusFFIArtifactsDir) is the location where regorus shared libraries have been 
         built for various platforms and copied to. RegorusFFIArtifactsDir is passed in

bindings/csharp/Regorus/RegorusFFI.cs

@@ -10,12 +10,14 @@
 
 namespace Regorus.Internal
 {
+    // Add the callback delegate definition
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    internal unsafe delegate byte* RegorusCallbackDelegate(byte* payload, void* context);
+    
     internal static unsafe partial class API
     {
         const string __DllName = "regorus_ffi";
 
-
-
         /// <summary>
         ///  Drop a `RegorusResult`.
         ///
@@ -192,7 +194,17 @@ internal static unsafe partial class API
         [DllImport(__DllName, EntryPoint = "regorus_engine_set_rego_v0", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern RegorusResult regorus_engine_set_rego_v0(RegorusEngine* engine, [MarshalAs(UnmanagedType.U1)] bool enable);
 
+        /// <summary>
+        /// Register a callback function that can be called from Rego policies
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "regorus_register_callback", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern RegorusStatus regorus_register_callback(byte* name, RegorusCallbackDelegate callback, void* context);
 
+        /// <summary>
+        /// Unregister a previously registered callback function
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "regorus_unregister_callback", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern RegorusStatus regorus_unregister_callback(byte* name);
     }
 
     [StructLayout(LayoutKind.Sequential)]

bindings/csharp/scripts/README.md

@@ -0,0 +1,8 @@
+# Steps to run invoke example
+
+1. Install dotnet-script
+1. `dotnet build` in `bindings/csharp/Regorus`
+1. `cargo build` in `bindings/ffi`
+1. Copy `bindings/ffi/target/debug/regorus_ffi.dll` to `bindings/csharp/scripts`
+1. `cd` to `bindings/csharp/scripts`
+1. Run `dotnet script invoke.csx`

bindings/csharp/scripts/invoke.csx

@@ -0,0 +1,44 @@
+#r "../Regorus/bin/Debug/netstandard2.1/Regorus.dll"
+// No direct reference to regorus_ffi.dll as it's a native DLL
+#r "nuget: Newtonsoft.Json, 13.0.2"
+#r "nuget: System.Data.Common, 4.3.0"
+
+// Create a new engine
+var engine = new Regorus.Engine();
+// Register a callback function
+bool registerResult = engine.RegisterCallback("test_callback", payload => {
+    Console.WriteLine($"Called with payload: {payload}");
+    
+    if (payload is System.Text.Json.JsonElement jsonElement)
+    {
+        // Access properties from JsonElement
+        var testValue = jsonElement.GetProperty("value").GetInt32();
+        
+        // Return a response object that will be serialized to JSON
+        return new Dictionary<string, object>
+        {
+            ["value"] = testValue * 2,
+            ["message"] = "Processing complete"
+        };
+    }
+    
+    return null;
+});
+
+Console.WriteLine($"Callback registration result: {registerResult}");
+
+// Add a policy that uses the callback
+engine.AddPolicy("example.rego", @"
+package example
+
+import future.keywords.if
+
+double_value := invoke(""test_callback"", {""value"": 42}).value
+");
+
+// Evaluate query
+var result = engine.EvalQuery("data.example.double_value");
+Console.WriteLine($"Result: {result}");
+
+// Unregister the callback when done
+engine.UnregisterCallback("test_callback");

bindings/ffi/Cargo.toml

@@ -24,3 +24,6 @@ custom_allocator = []
 [build-dependencies]
 cbindgen = "0.28.0"
 csbindgen = "=1.9.3"
+
+[dev-dependencies]
+csbindgen = "=1.9.3"