Better loading method and API + fixes

LucDeCaf · LucDeCaf · commit e910fc416e05 · 2026-05-19T13:02:04.000+02:00
diff --git a/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteAdapter.cs b/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteAdapter.cs
@@ -60,6 +60,7 @@ private RequiredMDSQLiteOptions ResolveMDSQLiteOptions(MDSQLiteOptions? options)
             LockTimeoutMs = options?.LockTimeoutMs ?? defaults.LockTimeoutMs,
             EncryptionKey = options?.EncryptionKey ?? defaults.EncryptionKey,
             Extensions = options?.Extensions ?? defaults.Extensions,
+            LoadPowerSyncExtension = options?.LoadPowerSyncExtension ?? defaults.LoadPowerSyncExtension,
             ReadPoolSize = options?.ReadPoolSize ?? defaults.ReadPoolSize,
         };
     }
@@ -105,7 +106,7 @@ private async Task Init()
             }
             return readConnection;
         };
-        readPool = new MDSQLiteConnectionPool(resolvedOptions, readConnectionFactory);
+        readPool = new MDSQLiteConnectionPool(resolvedOptions.ReadPoolSize, readConnectionFactory);
         await readPool.Init();
 
         // Register TablesUpdated listener
@@ -144,12 +145,27 @@ private static SqliteConnection OpenDatabase(string dbFilename)
     protected virtual void LoadExtensions(SqliteConnection db)
     {
         db.EnableExtensions(true);
+        if (resolvedOptions.LoadPowerSyncExtension)
+        {
+            LoadDefaultPowerSyncExtension(db);
+        }
         foreach (var extension in resolvedOptions.Extensions)
         {
             db.LoadExtension(extension.Path, extension.EntryPoint);
         }
     }
 
+    /// <summary>
+    /// Loads the bundled PowerSync core SQLite extension. Override on
+    /// platform-specific adapters (e.g. MAUI iOS/Android) where the native library
+    /// lives outside the desktop runtime path.
+    /// </summary>
+    protected virtual void LoadDefaultPowerSyncExtension(SqliteConnection db)
+    {
+        var path = PowerSyncPathResolver.GetNativeLibraryPath(AppContext.BaseDirectory);
+        db.LoadExtension(path, "sqlite3_powersync_init");
+    }
+
     public async Task Close()
     {
         tablesUpdatedCts?.Cancel();
@@ -303,18 +319,16 @@ await readPool.LeaseAll(async (connections) =>
 
 class MDSQLiteConnectionPool
 {
-    private readonly RequiredMDSQLiteOptions _options;
     private readonly Channel<MDSQLiteConnection> _channel;
     private readonly int _poolSize;
     private readonly Func<Task<MDSQLiteConnection>> _connectionFactory;
 
     private readonly Task _initialized;
 
-    public MDSQLiteConnectionPool(RequiredMDSQLiteOptions options, Func<Task<MDSQLiteConnection>> connectionFactory)
+    public MDSQLiteConnectionPool(int poolSize, Func<Task<MDSQLiteConnection>> connectionFactory)
     {
-        _options = options;
-        _channel = Channel.CreateBounded<MDSQLiteConnection>(options.ReadPoolSize);
-        _poolSize = options.ReadPoolSize;
+        _channel = Channel.CreateBounded<MDSQLiteConnection>(poolSize);
+        _poolSize = poolSize;
         _connectionFactory = connectionFactory;
         _initialized = Initialize();
     }
@@ -366,34 +380,6 @@ public async Task LeaseAll(Func<List<MDSQLiteConnection>, Task> callback)
         }
     }
 
-    private async Task<MDSQLiteConnection> OpenConnection(string dbFilename)
-    {
-        var db = OpenDatabase(dbFilename);
-        LoadExtensions(db);
-
-        var connection = new MDSQLiteConnection(new MDSQLiteConnectionOptions(db));
-        await connection.Execute("SELECT powersync_init()");
-
-        return connection;
-    }
-
-    private static SqliteConnection OpenDatabase(string dbFilename)
-    {
-        string connectionString = $"Data Source={dbFilename};Pooling=False;";
-        var connection = new SqliteConnection(connectionString);
-        connection.Open();
-        return connection;
-    }
-
-    private void LoadExtensions(SqliteConnection db)
-    {
-        db.EnableExtensions(true);
-        foreach (var extension in _options.Extensions)
-        {
-            db.LoadExtension(extension.Path, extension.EntryPoint);
-        }
-    }
-
     public async Task Close()
     {
         await LeaseAll((connections) =>
diff --git a/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteOptions.cs b/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteOptions.cs
@@ -1,7 +1,5 @@
 namespace PowerSync.Common.MDSQLite;
 
-using PowerSync.Common.Utils;
-
 public sealed class TemporaryStorageOption
 {
     public static readonly TemporaryStorageOption MEMORY = new("memory");
@@ -57,27 +55,10 @@ public sealed class SqliteSynchronous
 
 public class SqliteExtension
 {
-    public static SqliteExtension DEFAULT_POWERSYNC_EXTENSION = new()
-    {
-        Path = TryResolveDefaultPowerSyncExtensionPath(),
-        EntryPoint = "sqlite3_powersync_init",
-    };
-    public static SqliteExtension[] DEFAULT_POWERSYNC_EXTENSIONS = [DEFAULT_POWERSYNC_EXTENSION];
-
     public string Path { get; set; } = string.Empty;
     public string? EntryPoint { get; set; }
-
-    // PowerSyncPathResolver only knows about desktop RIDs and throws on iOS/Android.
-    // Swallow that here so this static field can be referenced safely on mobile —
-    // platform-aware adapters (e.g. MAUI) intercept the sentinel before reading Path.
-    private static string TryResolveDefaultPowerSyncExtensionPath()
-    {
-        try { return PowerSyncPathResolver.GetNativeLibraryPath(AppContext.BaseDirectory); }
-        catch (PlatformNotSupportedException) { return string.Empty; }
-    }
 }
 
-
 public class MDSQLiteOptions
 {
     /// <summary>
@@ -118,12 +99,23 @@ public class MDSQLiteOptions
     public int? CacheSizeKb { get; set; }
 
     /// <summary>
-    /// Load SQLite extensions using the path and entryPoint. Defaults to
-    /// SqliteExtension.DEFAULT_POWERSYNC_EXTENSIONS. Remember to re-add
-    /// the DEFAULT_POWERSYNC_EXTENSION if modifying the list of extensions.
+    /// Additional SQLite extensions to load on every connection, in order. Defaults
+    /// to an empty list. The bundled PowerSync core extension is loaded separately
+    /// and controlled by <see cref="LoadPowerSyncExtension"/> — do not include it
+    /// here.
     /// </summary>
     public SqliteExtension[]? Extensions { get; set; }
 
+    /// <summary>
+    /// Whether to load the bundled PowerSync core SQLite extension on every
+    /// connection. Defaults to true and should remain true for normal use — the
+    /// rest of the library relies on the SQL functions and virtual tables it
+    /// registers (e.g. <c>powersync_init()</c>). Set to false only if you are
+    /// supplying an equivalent PowerSync-compatible extension via
+    /// <see cref="Extensions"/>.
+    /// </summary>
+    public bool? LoadPowerSyncExtension { get; set; }
+
     /// <summary>
     /// The number of MDSQLiteConnection objects to create for the read pool.
     /// </summary>
@@ -141,7 +133,8 @@ public class RequiredMDSQLiteOptions : MDSQLiteOptions
         TemporaryStorage = TemporaryStorageOption.MEMORY,
         LockTimeoutMs = 30000,
         EncryptionKey = null,
-        Extensions = SqliteExtension.DEFAULT_POWERSYNC_EXTENSIONS,
+        Extensions = [],
+        LoadPowerSyncExtension = true,
         ReadPoolSize = 5,
     };
 
@@ -161,5 +154,7 @@ public class RequiredMDSQLiteOptions : MDSQLiteOptions
 
     public new SqliteExtension[] Extensions { get; set; } = null!;
 
+    public new bool LoadPowerSyncExtension { get; set; }
+
     public new int ReadPoolSize { get; set; }
 }
diff --git a/PowerSync/PowerSync.Maui/SQLite/MAUISQLiteAdapter.cs b/PowerSync/PowerSync.Maui/SQLite/MAUISQLiteAdapter.cs
@@ -15,45 +15,20 @@ public MAUISQLiteAdapter(MDSQLiteAdapterOptions options) : base(options)
     {
     }
 
-    protected override void LoadExtensions(SqliteConnection db)
-    {
-        db.EnableExtensions(true);
-
-        // The default PowerSync extension's path is resolved for desktop runtimes and
-        // does not apply on iOS/MacCatalyst/Android, where the native library lives
-        // in a platform-specific location. If the user didn't supply any extensions,
-        // load the platform-correct default. Otherwise honor their list — but still
-        // intercept the DEFAULT_POWERSYNC_EXTENSION sentinel so consumers can mix
-        // the bundled PowerSync extension with their own custom extensions.
-        var userExtensions = options.SqliteOptions?.Extensions;
-        if (userExtensions == null)
-        {
-            LoadDefaultPowerSyncExtension(db);
-            return;
-        }
-
-        foreach (var extension in userExtensions)
-        {
-            if (ReferenceEquals(extension, SqliteExtension.DEFAULT_POWERSYNC_EXTENSION))
-            {
-                LoadDefaultPowerSyncExtension(db);
-            }
-            else
-            {
-                db.LoadExtension(extension.Path, extension.EntryPoint);
-            }
-        }
-    }
-
-    private static void LoadDefaultPowerSyncExtension(SqliteConnection db)
+    // The bundled PowerSync extension lives in a platform-specific location on
+    // iOS/MacCatalyst/Android — the desktop runtime path used by the base class
+    // does not resolve to it. Override only the PowerSync-extension load hook;
+    // user-supplied custom extensions still flow through MDSQLiteAdapter.LoadExtensions
+    // unchanged, so consumers can freely combine the bundled extension (via the
+    // LoadPowerSyncExtension flag) with their own.
+    protected override void LoadDefaultPowerSyncExtension(SqliteConnection db)
     {
 #if IOS || MACCATALYST
         LoadExtensionApple(db);
 #elif ANDROID
         db.LoadExtension("libpowersync");
 #else
-        var defaultExtension = SqliteExtension.DEFAULT_POWERSYNC_EXTENSION;
-        db.LoadExtension(defaultExtension.Path, defaultExtension.EntryPoint);
+        base.LoadDefaultPowerSyncExtension(db);
 #endif
     }
 
diff --git a/Tests/PowerSync/PowerSync.Common.Tests/MDSQLite/MDSQLiteAdapterTests.cs b/Tests/PowerSync/PowerSync.Common.Tests/MDSQLite/MDSQLiteAdapterTests.cs
@@ -5,6 +5,7 @@ namespace PowerSync.Common.Tests.MDSQLite;
 using PowerSync.Common.Client;
 using PowerSync.Common.MDSQLite;
 using PowerSync.Common.Tests.Utils;
+using PowerSync.Common.Utils;
 
 /// <summary>
 /// dotnet test -v n --framework net8.0 --filter "MDSQLiteAdapterTests"
@@ -19,35 +20,23 @@ private class AssetResult
         public string? make { get; set; }
     }
 
-    private static PowerSyncDatabase BuildDbWithExtensions(string dbFilename, SqliteExtension[] extensions)
+    [Fact]
+    public async Task DisablingCoreExtensionPreventsPowerSyncFromLoading()
     {
-        return new PowerSyncDatabase(new PowerSyncDatabaseOptions
+        var dbName = $"MDSQLiteAdapter-{Guid.NewGuid():N}.db";
+        var db = new PowerSyncDatabase(new PowerSyncDatabaseOptions
         {
             Database = new MDSQLiteDBOpenFactory(new MDSQLiteOpenFactoryOptions
             {
-                DbFilename = dbFilename,
-                SqliteOptions = new MDSQLiteOptions { Extensions = extensions },
+                DbFilename = dbName,
+                SqliteOptions = new MDSQLiteOptions
+                {
+                    LoadPowerSyncExtension = false,
+                    Extensions = [],
+                },
             }),
             Schema = TestSchema.AppSchema,
         });
-    }
-
-    private static string CopyDefaultExtensionToTempPath()
-    {
-        var sourcePath = SqliteExtension.DEFAULT_POWERSYNC_EXTENSION.Path;
-        var tempPath = Path.Combine(
-            Path.GetTempPath(),
-            $"powersync-ext-copy-{Guid.NewGuid():N}{Path.GetExtension(sourcePath)}"
-        );
-        File.Copy(sourcePath, tempPath, overwrite: true);
-        return tempPath;
-    }
-
-    [Fact]
-    public async Task EmptyExtensionsArrayDoesNotLoadPowerSync()
-    {
-        var name = $"MDSQLiteAdapter-ext-empty-{Guid.NewGuid():N}.db";
-        var db = BuildDbWithExtensions(name, []);
 
         try
         {
@@ -57,18 +46,36 @@ public async Task EmptyExtensionsArrayDoesNotLoadPowerSync()
         finally
         {
             try { await db.Close(); } catch { /* expected — init failed */ }
-            DatabaseUtils.CleanDb(name);
+            DatabaseUtils.CleanDb(dbName);
         }
     }
 
     [Fact]
     public async Task LoadsCustomPowerSyncExtensionFromOverriddenPath()
     {
-        var name = $"MDSQLiteAdapter-ext-custom-{Guid.NewGuid():N}.db";
-        var customPath = CopyDefaultExtensionToTempPath();
-        var db = BuildDbWithExtensions(name, [
-            new SqliteExtension { Path = customPath, EntryPoint = "sqlite3_powersync_init" },
-        ]);
+        var dbName = $"MDSQLiteAdapter-{Guid.NewGuid():N}.db";
+        var sourcePath = PowerSyncPathResolver.GetNativeLibraryPath(AppContext.BaseDirectory);
+        var customPath = Path.Combine(
+            Path.GetTempPath(),
+            $"powersync-ext-copy-{Guid.NewGuid():N}{Path.GetExtension(sourcePath)}"
+        );
+        File.Copy(sourcePath, customPath, overwrite: true);
+
+        var db = new PowerSyncDatabase(new PowerSyncDatabaseOptions
+        {
+            Database = new MDSQLiteDBOpenFactory(new MDSQLiteOpenFactoryOptions
+            {
+                DbFilename = dbName,
+                SqliteOptions = new MDSQLiteOptions
+                {
+                    LoadPowerSyncExtension = false,
+                    Extensions = [
+                        new SqliteExtension { Path = customPath, EntryPoint = "sqlite3_powersync_init" },
+                    ],
+                },
+            }),
+            Schema = TestSchema.AppSchema,
+        });
 
         try
         {
@@ -82,7 +89,7 @@ public async Task LoadsCustomPowerSyncExtensionFromOverriddenPath()
         finally
         {
             await db.Close();
-            DatabaseUtils.CleanDb(name);
+            DatabaseUtils.CleanDb(dbName);
             try { File.Delete(customPath); } catch { /* best-effort cleanup */ }
         }
     }
