✨ implement Import method

SurrealDb.Embedded.InMemory/NativeMethods.g.cs

@@ -34,6 +34,14 @@ internal static unsafe partial class NativeMethods
         [DllImport(__DllName, EntryPoint = "execute", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern void execute(int id, Method method, byte* bytes, int len, SuccessAction success, FailureAction failure);
 
+        /// <summary>
+        ///  # Safety
+        ///
+        ///  Executes the "import" method of a SurrealDB engine (given its id).
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "import", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void import(int id, ushort* utf16_str, int utf16_len, SuccessAction success, FailureAction failure);
+
         /// <summary>
         ///  # Safety
         ///

SurrealDb.Embedded.Internals/SurrealDbEmbeddedEngine.cs

@@ -337,6 +337,83 @@
         }
     }
 
+    public async Task Import(string input, CancellationToken cancellationToken)
+    {
+        using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        cancellationToken.Register(timeoutCts.Cancel);
+
+        var taskCompletionSource = new TaskCompletionSource<Unit>();
+        timeoutCts.Token.Register(() =>
+        {
+            taskCompletionSource.TrySetCanceled();
+        });
+
+        Action<ByteBuffer> success = (_) =>
+        {
+            try
+            {
+                taskCompletionSource.SetResult(default);
+            }
+            catch (Exception e)
+            {
+                taskCompletionSource.SetException(e);
+            }
+        };
+        Action<ByteBuffer> fail = (byteBuffer) =>
+        {
+            string error = CborSerializer.Deserialize<string>(
+                byteBuffer.AsReadOnly(),
+                GetCborOptions()
+            );
+            taskCompletionSource.SetException(new SurrealDbException(error));
+        };
+
+        var successHandle = GCHandle.Alloc(success);
+        var failureHandle = GCHandle.Alloc(fail);
+
+        unsafe
+        {
+            var successAction = new SuccessAction()
+            {
+                handle = new RustGCHandle()
+                {
+                    ptr = GCHandle.ToIntPtr(successHandle),
+                    drop_callback = &NativeBindings.DropGcHandle,
+                },
+                callback = &NativeBindings.SuccessCallback,
+            };
+
+            var failureAction = new FailureAction()
+            {
+                handle = new RustGCHandle()
+                {
+                    ptr = GCHandle.ToIntPtr(failureHandle),
+                    drop_callback = &NativeBindings.DropGcHandle,
+                },
+                callback = &NativeBindings.FailureCallback,
+            };
+
+            fixed (char* p = input.AsSpan())
+            {
+                NativeMethods.import(_id, (ushort*)p, input.Length, successAction, failureAction);
+            }
+        }
+
+        try
+        {
+            await taskCompletionSource.Task.ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            if (!cancellationToken.IsCancellationRequested)
+            {
+                throw new TimeoutException();
+            }
+
+            throw;
+        }
+    }
+
     public Task<T> Info<T>(CancellationToken cancellationToken)
     {
         throw new NotSupportedException("Authentication is not enabled in embedded mode.");

SurrealDb.Embedded.RocksDb/NativeMethods.g.cs

@@ -34,6 +34,14 @@ internal static unsafe partial class NativeMethods
         [DllImport(__DllName, EntryPoint = "execute", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern void execute(int id, Method method, byte* bytes, int len, SuccessAction success, FailureAction failure);
 
+        /// <summary>
+        ///  # Safety
+        ///
+        ///  Executes the "import" method of a SurrealDB engine (given its id).
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "import", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void import(int id, ushort* utf16_str, int utf16_len, SuccessAction success, FailureAction failure);
+
         /// <summary>
         ///  # Safety
         ///

SurrealDb.Embedded.SurrealKv/NativeMethods.g.cs

@@ -34,6 +34,14 @@ internal static unsafe partial class NativeMethods
         [DllImport(__DllName, EntryPoint = "execute", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern void execute(int id, Method method, byte* bytes, int len, SuccessAction success, FailureAction failure);
 
+        /// <summary>
+        ///  # Safety
+        ///
+        ///  Executes the "import" method of a SurrealDB engine (given its id).
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "import", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void import(int id, ushort* utf16_str, int utf16_len, SuccessAction success, FailureAction failure);
+
         /// <summary>
         ///  # Safety
         ///

SurrealDb.Net.Tests/ImportTests.cs

@@ -0,0 +1,50 @@
+namespace SurrealDb.Net.Tests;
+
+public class ImportTests
+{
+    private const string IMPORT_QUERY = """
+        DEFINE TABLE foo SCHEMALESS;
+        DEFINE TABLE bar SCHEMALESS;
+        CREATE foo:1 CONTENT { hello: "world" };
+        CREATE bar:1 CONTENT { hello: "world" };
+        DEFINE FUNCTION fn::foo() {
+          RETURN "bar";
+        };
+        """;
+
+    [Test]
+    [ConnectionStringFixtureGenerator]
+    public async Task ShouldImportDataSuccessfully(string connectionString)
+    {
+        var version = await SurrealDbClientGenerator.GetSurrealTestVersion(connectionString);
+        if (version?.Major < 2)
+        {
+            return;
+        }
+
+        await using var surrealDbClientGenerator = new SurrealDbClientGenerator();
+        var dbInfo = surrealDbClientGenerator.GenerateDatabaseInfo();
+
+        var client = surrealDbClientGenerator.Create(connectionString);
+        await client.Use(dbInfo.Namespace, dbInfo.Database);
+
+        Func<Task> func = async () =>
+        {
+            await client.Import(IMPORT_QUERY);
+        };
+
+        await func.Should().NotThrowAsync();
+
+        // Check imported query by querying the db
+        var fooRecords = await client.Select<object>("foo");
+        fooRecords.Should().NotBeNull().And.HaveCount(1);
+
+        var barRecords = await client.Select<object>("bar");
+        barRecords.Should().NotBeNull().And.HaveCount(1);
+
+        var fnResult = await client.Run<string>("fn::foo");
+        fnResult.Should().Be("bar");
+
+        await client.DisposeAsync();
+    }
+}

SurrealDb.Net/Internals/Http/CommonHttpWrapper.cs

@@ -0,0 +1,16 @@
+using Dahomey.Cbor;
+using Semver;
+
+namespace SurrealDb.Net.Internals.Http;
+
+internal sealed record CommonHttpWrapper(
+    HttpClient HttpClient,
+    SemVersion? Version,
+    Action<CborOptions>? ConfigureCborOptions
+) : IDisposable
+{
+    public void Dispose()
+    {
+        HttpClient.Dispose();
+    }
+}

SurrealDb.Net/Internals/SurrealDbEngine.Interface.cs

@@ -194,6 +194,16 @@ void Initialize(
     /// <param name="cancellationToken">The cancellationToken enables graceful cancellation of asynchronous operations</param>
     /// <returns>SurrealQL script as <see cref="String"/></returns>
     Task<string> Export(ExportOptions? options, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// This method imports data into a SurrealDB database.
+    /// </summary>
+    /// <remarks>
+    /// This method is only supported by SurrealDB v2.0.0 or higher.
+    /// </remarks>
+    /// <param name="input"></param>
+    /// <param name="cancellationToken">The cancellationToken enables graceful cancellation of asynchronous operations</param>
+    Task Import(string input, CancellationToken cancellationToken = default);
 }
 
 public interface ISurrealDbInMemoryEngine : ISurrealDbProviderEngine { }

SurrealDb.Net/SurrealDbClient.Base.cs

@@ -1,8 +1,12 @@
 using Dahomey.Cbor;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Semver;
+using SurrealDb.Net.Exceptions;
 using SurrealDb.Net.Extensions.DependencyInjection;
 using SurrealDb.Net.Internals;
+using SurrealDb.Net.Internals.Auth;
+using SurrealDb.Net.Internals.Http;
 
 namespace SurrealDb.Net;
 
@@ -26,4 +30,57 @@
             loggerFactory is not null ? new SurrealDbLoggerFactory(loggerFactory) : null
         );
     }
+
+    private async Task<CommonHttpWrapper> CreateCommonHttpWrapperAsync(
+        CancellationToken cancellationToken
+    )
+    {
+        SemVersion? version;
+        string? ns;
+        string? db;
+        IAuth? auth;
+        Action<CborOptions>? configureCborOptions;
+
+        switch (_engine)
+        {
+            case SurrealDbHttpEngine httpEngine:
+                // 💡 Ensures underlying engine is started to retrieve some information
+                await httpEngine.Connect(cancellationToken).ConfigureAwait(false);
+
+                version = httpEngine._version;
+                ns = httpEngine._config.Ns;
+                db = httpEngine._config.Db;
+                auth = httpEngine._config.Auth;
+                configureCborOptions = httpEngine._configureCborOptions;
+                break;
+            case SurrealDbWsEngine wsEngine:
+                // 💡 Ensures underlying engine is started to retrieve some information
+                await wsEngine.InternalConnectAsync(true, cancellationToken).ConfigureAwait(false);
+
+                version = wsEngine._version;
+                ns = wsEngine._config.Ns;
+                db = wsEngine._config.Db;
+                auth = wsEngine._config.Auth;
+                configureCborOptions = wsEngine._configureCborOptions;
+                break;
+            default:
+                throw new SurrealDbException("No underlying engine is started.");
+        }
+
+        if (string.IsNullOrWhiteSpace(ns))
+        {
+            throw new SurrealDbException("Namespace should be provided to export data.");
+        }
+        if (string.IsNullOrWhiteSpace(db))
+        {
+            throw new SurrealDbException("Database should be provided to export data.");
+        }
+
+        var httpClient = new HttpClient();
+
+        SurrealDbHttpEngine.SetNsDbHttpClientHeaders(httpClient, version, ns, db);
+        SurrealDbHttpEngine.SetAuthHttpClientHeaders(httpClient, auth);
+
+        return new CommonHttpWrapper(httpClient, version, configureCborOptions);
+    }
 }

SurrealDb.Net/SurrealDbClient.Interface.cs

@@ -166,6 +166,16 @@ Task<string> Export(
     /// <exception cref="SurrealDbException"></exception>
     Task<bool> Health(CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// This method imports data into a SurrealDB database.
+    /// </summary>
+    /// <remarks>
+    /// This method is only supported by SurrealDB v2.0.0 or higher.
+    /// </remarks>
+    /// <param name="input"></param>
+    /// <param name="cancellationToken">The cancellationToken enables graceful cancellation of asynchronous operations</param>
+    Task Import(string input, CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Retrieves information about the authenticated scope user.
     /// </summary>