strata-storage 2.4.3 → 2.6.0

package/android/src/main/java/com/stratastorage/StrataStoragePlugin.java

@@ -1,61 +1,132 @@
 package com.stratastorage;
 
 import com.getcapacitor.JSObject;
+import com.getcapacitor.JSArray;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
 import com.strata.storage.SharedPreferencesStorage;
 import com.strata.storage.EncryptedStorage;
+import com.strata.storage.FilesystemStorage;
 import com.strata.storage.SQLiteStorage;
 import android.util.Log;
 import org.json.JSONArray;
-import org.json.JSONException;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Main Capacitor plugin for Strata Storage
- * Coordinates between different storage types on Android
+ * Coordinates between different storage types on Android.
+ *
+ * Storage types with a real native backend: preferences, secure, sqlite,
+ * filesystem.
+ *
+ * SQLite supports multi-store: the `database` option selects the DB file and
+ * `table` selects the table within it. SQLite helper instances are cached per
+ * database name so the connection is not reopened per call.
  */
 @CapacitorPlugin(name = "StrataStorage")
 public class StrataStoragePlugin extends Plugin {
+    private static final String DEFAULT_DATABASE = "strata_storage";
+    private static final String DEFAULT_TABLE = "storage";
+
     private SharedPreferencesStorage sharedPrefsStorage;
     private EncryptedStorage encryptedStorage;
-    private SQLiteStorage sqliteStorage;
+    private FilesystemStorage filesystemStorage;
+
+    /** SQLite helper cache keyed by resolved database name (without ".db"). */
+    private final Map<String, SQLiteStorage> sqliteStores = new HashMap<>();
 
     @Override
     public void load() {
         try {
             sharedPrefsStorage = new SharedPreferencesStorage(getContext());
+        } catch (Exception e) {
+            Log.e("StrataStorage", "Failed to initialize preferences storage", e);
+        }
+        try {
             encryptedStorage = new EncryptedStorage(getContext());
-            sqliteStorage = new SQLiteStorage(getContext());
         } catch (Exception e) {
-            // Log error but don't crash - some storage types may not be available
-            Log.e("StrataStorage", "Failed to initialize storage", e);
+            // Secure storage may be unavailable on some devices/keystores —
+            // keep the rest of the plugin functional.
+            Log.e("StrataStorage", "Failed to initialize encrypted storage", e);
+        }
+        try {
+            filesystemStorage = new FilesystemStorage(getContext());
+        } catch (Exception e) {
+            Log.e("StrataStorage", "Failed to initialize filesystem storage", e);
+        }
+    }
+
+    /**
+     * Sanitize a database name to a safe file stem ({@code ^[A-Za-z0-9_]+$})
+     * and return the resolved stem. The ".db" suffix is appended when opening.
+     */
+    private static String sanitizeDatabase(String database) {
+        if (database == null || database.isEmpty()) {
+            return DEFAULT_DATABASE;
+        }
+        String cleaned = database.replaceAll("[^A-Za-z0-9_]", "");
+        return cleaned.isEmpty() ? DEFAULT_DATABASE : cleaned;
+    }
+
+    /**
+     * Return (creating + caching on first use) the SQLite helper for the given
+     * database name. The cache is keyed by the sanitized DB stem so the
+     * connection is reused across bridge calls. May return {@code null} if the
+     * helper cannot be constructed.
+     */
+    private synchronized SQLiteStorage getSqliteStore(String database) {
+        String dbStem = sanitizeDatabase(database);
+        SQLiteStorage store = sqliteStores.get(dbStem);
+        if (store == null) {
+            try {
+                store = new SQLiteStorage(getContext(), dbStem + ".db");
+                sqliteStores.put(dbStem, store);
+            } catch (Exception e) {
+                Log.e("StrataStorage", "Failed to open SQLite database " + dbStem, e);
+                return null;
+            }
         }
+        return store;
     }
 
     /**
-     * Check if storage is available
+     * Check if a specific storage type is available.
+     * Matches the JS contract: resolves { available: boolean }.
      */
     @PluginMethod
     public void isAvailable(PluginCall call) {
+        String storage = call.getString("storage", "preferences");
+        boolean available;
+        switch (storage) {
+            case "secure":
+                available = encryptedStorage != null;
+                break;
+            case "sqlite":
+                available = getSqliteStore(call.getString("database", DEFAULT_DATABASE)) != null;
+                break;
+            case "filesystem":
+                available = filesystemStorage != null;
+                break;
+            case "preferences":
+            default:
+                available = sharedPrefsStorage != null;
+                break;
+        }
+
         JSObject result = new JSObject();
-        result.put("available", true);
-        result.put("platform", "android");
-        
-        JSObject adapters = new JSObject();
-        adapters.put("preferences", true);
-        adapters.put("secure", true);
-        adapters.put("sqlite", true);
-        adapters.put("filesystem", true);
-        result.put("adapters", adapters);
-        
+        result.put("available", available);
         call.resolve(result);
     }
 
     /**
-     * Get value from storage
+     * Get value from storage.
+     *
+     * For sqlite/filesystem the resolved `value` is the full wrapper object
+     * (parsed back from JSON). A miss resolves `value` = null.
      */
     @PluginMethod
     public void get(PluginCall call) {
@@ -66,45 +137,72 @@ public class StrataStoragePlugin extends Plugin {
         }
 
         String storage = call.getString("storage", "preferences");
-        
-        try {
-            Object value = null;
 
+        try {
             switch (storage) {
-                case "secure":
+                case "secure": {
                     if (encryptedStorage == null) {
                         call.reject("Encrypted storage not available");
                         return;
                     }
-                    value = encryptedStorage.get(key);
-                    break;
-                case "sqlite":
-                    if (sqliteStorage == null) {
+                    resolveValue(call, encryptedStorage.get(key));
+                    return;
+                }
+                case "sqlite": {
+                    SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+                    if (store == null) {
                         call.reject("SQLite storage not available");
                         return;
                     }
-                    value = sqliteStorage.get(key);
-                    break;
+                    String table = call.getString("table", DEFAULT_TABLE);
+                    resolveValue(call, store.get(table, key));
+                    return;
+                }
+                case "filesystem": {
+                    if (filesystemStorage == null) {
+                        call.reject("Filesystem storage not available");
+                        return;
+                    }
+                    resolveValue(call, filesystemStorage.get(key));
+                    return;
+                }
                 case "preferences":
-                default:
+                default: {
                     if (sharedPrefsStorage == null) {
                         call.reject("Preferences storage not available");
                         return;
                     }
-                    value = sharedPrefsStorage.get(key);
-                    break;
+                    resolveValue(call, sharedPrefsStorage.get(key));
+                    return;
+                }
             }
-
-            JSObject result = new JSObject();
-            result.put("value", value);
-            call.resolve(result);
         } catch (Exception e) {
             call.reject("Failed to get value", e);
         }
     }
 
     /**
-     * Set value in storage
+     * Resolve a get() call, mapping a Java {@code null} to a JS {@code null}
+     * value so the TS adapters treat it as a miss.
+     */
+    private void resolveValue(PluginCall call, Object value) {
+        JSObject result = new JSObject();
+        if (value == null) {
+            result.put("value", JSObject.NULL);
+        } else {
+            result.put("value", value);
+        }
+        call.resolve(result);
+    }
+
+    /**
+     * Set value in storage.
+     *
+     * For sqlite/filesystem the `value` is the FULL wrapper object
+     * ({ value, created, updated, expires?, tags?, metadata? }); it is read via
+     * call.getObject("value") and stored verbatim (with TTL/query columns
+     * extracted for sqlite). For preferences/secure the raw value is forwarded
+     * unchanged.
      */
     @PluginMethod
     public void set(PluginCall call) {
@@ -114,35 +212,59 @@ public class StrataStoragePlugin extends Plugin {
             return;
         }
 
-        Object value = call.getData().opt("value");
         String storage = call.getString("storage", "preferences");
-        
+
         try {
+            boolean ok;
             switch (storage) {
                 case "secure":
                     if (encryptedStorage == null) {
                         call.reject("Encrypted storage not available");
                         return;
                     }
-                    encryptedStorage.set(key, value);
+                    ok = encryptedStorage.set(key, call.getData().opt("value"));
                     break;
-                case "sqlite":
-                    if (sqliteStorage == null) {
+                case "sqlite": {
+                    SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+                    if (store == null) {
                         call.reject("SQLite storage not available");
                         return;
                     }
-                    sqliteStorage.set(key, value);
+                    JSObject wrapper = call.getObject("value");
+                    if (wrapper == null) {
+                        call.reject("A wrapper object 'value' is required for sqlite storage");
+                        return;
+                    }
+                    ok = store.set(call.getString("table", DEFAULT_TABLE), key, wrapper);
                     break;
+                }
+                case "filesystem": {
+                    if (filesystemStorage == null) {
+                        call.reject("Filesystem storage not available");
+                        return;
+                    }
+                    JSObject wrapper = call.getObject("value");
+                    if (wrapper == null) {
+                        call.reject("A wrapper object 'value' is required for filesystem storage");
+                        return;
+                    }
+                    ok = filesystemStorage.set(key, wrapper);
+                    break;
+                }
                 case "preferences":
                 default:
                     if (sharedPrefsStorage == null) {
                         call.reject("Preferences storage not available");
                         return;
                     }
-                    sharedPrefsStorage.set(key, value);
+                    ok = sharedPrefsStorage.set(key, call.getData().opt("value"));
                     break;
             }
 
+            if (!ok) {
+                call.reject("Failed to persist value to " + storage + " storage");
+                return;
+            }
             call.resolve();
         } catch (Exception e) {
             call.reject("Failed to set value", e);
@@ -161,7 +283,7 @@ public class StrataStoragePlugin extends Plugin {
         }
 
         String storage = call.getString("storage", "preferences");
-        
+
         try {
             switch (storage) {
                 case "secure":
@@ -171,12 +293,21 @@ public class StrataStoragePlugin extends Plugin {
                     }
                     encryptedStorage.remove(key);
                     break;
-                case "sqlite":
-                    if (sqliteStorage == null) {
+                case "sqlite": {
+                    SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+                    if (store == null) {
                         call.reject("SQLite storage not available");
                         return;
                     }
-                    sqliteStorage.remove(key);
+                    store.remove(call.getString("table", DEFAULT_TABLE), key);
+                    break;
+                }
+                case "filesystem":
+                    if (filesystemStorage == null) {
+                        call.reject("Filesystem storage not available");
+                        return;
+                    }
+                    filesystemStorage.remove(key);
                     break;
                 case "preferences":
                 default:
@@ -195,13 +326,17 @@ public class StrataStoragePlugin extends Plugin {
     }
 
     /**
-     * Clear storage
+     * Clear storage.
+     * Accepts the JS `pattern` (used as a key prefix) and a legacy `prefix`.
      */
     @PluginMethod
     public void clear(PluginCall call) {
         String storage = call.getString("storage", "preferences");
-        String prefix = call.getString("prefix");
-        
+        String prefix = call.getString("pattern");
+        if (prefix == null) {
+            prefix = call.getString("prefix");
+        }
+
         try {
             switch (storage) {
                 case "secure":
@@ -211,12 +346,21 @@ public class StrataStoragePlugin extends Plugin {
                     }
                     encryptedStorage.clear(prefix);
                     break;
-                case "sqlite":
-                    if (sqliteStorage == null) {
+                case "sqlite": {
+                    SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+                    if (store == null) {
                         call.reject("SQLite storage not available");
                         return;
                     }
-                    sqliteStorage.clear(prefix);
+                    store.clear(call.getString("table", DEFAULT_TABLE), prefix);
+                    break;
+                }
+                case "filesystem":
+                    if (filesystemStorage == null) {
+                        call.reject("Filesystem storage not available");
+                        return;
+                    }
+                    filesystemStorage.clear(prefix);
                     break;
                 case "preferences":
                 default:
@@ -241,9 +385,9 @@ public class StrataStoragePlugin extends Plugin {
     public void keys(PluginCall call) {
         String storage = call.getString("storage", "preferences");
         String pattern = call.getString("pattern");
-        
+
         try {
-            List<String> keys = null;
+            List<String> keys;
 
             switch (storage) {
                 case "secure":
@@ -253,12 +397,21 @@ public class StrataStoragePlugin extends Plugin {
                     }
                     keys = encryptedStorage.keys(pattern);
                     break;
-                case "sqlite":
-                    if (sqliteStorage == null) {
+                case "sqlite": {
+                    SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+                    if (store == null) {
                         call.reject("SQLite storage not available");
                         return;
                     }
-                    keys = sqliteStorage.keys(pattern);
+                    keys = store.keys(call.getString("table", DEFAULT_TABLE), pattern);
+                    break;
+                }
+                case "filesystem":
+                    if (filesystemStorage == null) {
+                        call.reject("Filesystem storage not available");
+                        return;
+                    }
+                    keys = filesystemStorage.keys(pattern);
                     break;
                 case "preferences":
                 default:
@@ -279,17 +432,21 @@ public class StrataStoragePlugin extends Plugin {
     }
 
     /**
-     * Get storage size information
+     * Get storage size information.
+     *
+     * When `detailed` is true the result also carries a byte breakdown
+     * { detailed: { keys, values, metadata } }.
      */
     @PluginMethod
     public void size(PluginCall call) {
         String storage = call.getString("storage", "preferences");
-        
+        boolean detailed = Boolean.TRUE.equals(call.getBoolean("detailed", false));
+
         try {
             JSObject result = new JSObject();
 
             switch (storage) {
-                case "secure":
+                case "secure": {
                     if (encryptedStorage == null) {
                         call.reject("Encrypted storage not available");
                         return;
@@ -298,17 +455,29 @@ public class StrataStoragePlugin extends Plugin {
                     result.put("total", encryptedSizeInfo.total);
                     result.put("count", encryptedSizeInfo.count);
                     break;
-                case "sqlite":
-                    if (sqliteStorage == null) {
+                }
+                case "sqlite": {
+                    SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+                    if (store == null) {
                         call.reject("SQLite storage not available");
                         return;
                     }
-                    SQLiteStorage.SizeInfo sqliteSizeInfo = sqliteStorage.size();
-                    result.put("total", sqliteSizeInfo.total);
-                    result.put("count", sqliteSizeInfo.count);
+                    SQLiteStorage.SizeInfo sqliteSizeInfo =
+                            store.size(call.getString("table", DEFAULT_TABLE), detailed);
+                    putSizeInfo(result, sqliteSizeInfo);
                     break;
+                }
+                case "filesystem": {
+                    if (filesystemStorage == null) {
+                        call.reject("Filesystem storage not available");
+                        return;
+                    }
+                    SQLiteStorage.SizeInfo fsSizeInfo = filesystemStorage.size(detailed);
+                    putSizeInfo(result, fsSizeInfo);
+                    break;
+                }
                 case "preferences":
-                default:
+                default: {
                     if (sharedPrefsStorage == null) {
                         call.reject("Preferences storage not available");
                         return;
@@ -317,6 +486,7 @@ public class StrataStoragePlugin extends Plugin {
                     result.put("total", prefsSizeInfo.total);
                     result.put("count", prefsSizeInfo.count);
                     break;
+                }
             }
 
             call.resolve(result);
@@ -324,5 +494,123 @@ public class StrataStoragePlugin extends Plugin {
             call.reject("Failed to get size", e);
         }
     }
-    
-}
+
+    /**
+     * Populate a size result, including the detailed byte breakdown when the
+     * {@link SQLiteStorage.SizeInfo} carries one.
+     */
+    private void putSizeInfo(JSObject result, SQLiteStorage.SizeInfo info) {
+        result.put("total", info.total);
+        result.put("count", info.count);
+        if (info.detailed) {
+            JSObject breakdown = new JSObject();
+            breakdown.put("keys", info.keysBytes);
+            breakdown.put("values", info.valuesBytes);
+            breakdown.put("metadata", info.metadataBytes);
+            result.put("detailed", breakdown);
+        }
+    }
+
+    /**
+     * Query SQLite-backed storage.
+     * Matches the optional `query` method in the JS contract:
+     * resolves { results: [{ key }] }. The JS SqliteAdapter applies the real
+     * condition by re-fetching/filtering, so this enumerates candidate keys.
+     */
+    @PluginMethod
+    public void query(PluginCall call) {
+        String storage = call.getString("storage", "sqlite");
+        if (!"sqlite".equals(storage)) {
+            call.reject("Query is only supported for the 'sqlite' storage type");
+            return;
+        }
+        SQLiteStorage store = getSqliteStore(call.getString("database", DEFAULT_DATABASE));
+        if (store == null) {
+            call.reject("SQLite storage not available");
+            return;
+        }
+
+        try {
+            List<Map<String, Object>> rows = store.query(call.getString("table", DEFAULT_TABLE));
+            JSArray results = new JSArray();
+            for (Map<String, Object> row : rows) {
+                JSObject obj = new JSObject();
+                obj.put("key", row.get("key"));
+                results.put(obj);
+            }
+            JSObject result = new JSObject();
+            result.put("results", results);
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Failed to query SQLite", e);
+        }
+    }
+
+    /**
+     * Android-specific: read an encrypted preference.
+     * Resolves { value: unknown }. Honors an optional `fileName`.
+     */
+    @PluginMethod
+    public void getEncryptedPreference(PluginCall call) {
+        String key = call.getString("key");
+        if (key == null) {
+            call.reject("Key is required");
+            return;
+        }
+        String fileName = call.getString("fileName");
+
+        try {
+            EncryptedStorage store = resolveEncryptedStore(fileName);
+            if (store == null) {
+                call.reject("Encrypted storage not available");
+                return;
+            }
+            JSObject result = new JSObject();
+            result.put("value", store.get(key));
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Failed to read encrypted preference", e);
+        }
+    }
+
+    /**
+     * Android-specific: write an encrypted preference. Honors an optional
+     * `fileName`.
+     */
+    @PluginMethod
+    public void setEncryptedPreference(PluginCall call) {
+        String key = call.getString("key");
+        if (key == null) {
+            call.reject("Key is required");
+            return;
+        }
+        Object value = call.getData().opt("value");
+        String fileName = call.getString("fileName");
+
+        try {
+            EncryptedStorage store = resolveEncryptedStore(fileName);
+            if (store == null) {
+                call.reject("Encrypted storage not available");
+                return;
+            }
+            if (!store.set(key, value)) {
+                call.reject("Failed to persist encrypted preference");
+                return;
+            }
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to write encrypted preference", e);
+        }
+    }
+
+    /**
+     * Returns the default encrypted store, or builds a file-specific one when a
+     * custom file name is supplied.
+     */
+    private EncryptedStorage resolveEncryptedStore(String fileName) throws Exception {
+        if (fileName == null || fileName.isEmpty()) {
+            return encryptedStorage;
+        }
+        return new EncryptedStorage(getContext(), fileName);
+    }
+}