strata-storage 2.6.0 → 2.7.0

package/android/src/main/java/com/strata/storage/FilesystemStorage.java

@@ -1,6 +1,7 @@
 package com.strata.storage;
 
 import android.content.Context;
+import android.os.Build;
 import android.util.Log;
 import com.getcapacitor.JSObject;
 import java.io.File;
@@ -124,16 +125,9 @@ public class FilesystemStorage {
             fos.close();
             fos = null;
 
-            // Rename is atomic on the same filesystem. Remove a stale target
-            // first since File.renameTo can fail when the destination exists.
-            if (target.exists() && !target.delete()) {
-                Log.w("StrataStorage", "Could not delete existing file before rename: " + key);
-            }
-            if (!tmp.renameTo(target)) {
-                tmp.delete();
-                return false;
-            }
-            return true;
+            // Commit the temp file over the target WITHOUT a delete-then-rename
+            // window (which could lose the existing value if the rename failed).
+            return commitAtomically(tmp, target, key);
         } catch (IOException e) {
             Log.e("StrataStorage", "Failed to set filesystem value for key " + key, e);
             if (tmp.exists()) {
@@ -151,6 +145,64 @@ public class FilesystemStorage {
         }
     }
 
+    /**
+     * Commit {@code tmp} over {@code target} without ever leaving the key with no
+     * value. The old delete-then-rename approach could lose the existing value
+     * if the rename failed after the delete succeeded.
+     *
+     * <p>Strategy: on API 26+ use an atomic NIO move (REPLACE_EXISTING +
+     * ATOMIC_MOVE). Otherwise try a direct {@code renameTo} (which atomically
+     * replaces on app-internal ext4/f2fs); only if that fails do we move the old
+     * value aside to a backup, swap in the new one, and restore the backup if the
+     * final rename fails — so the old value is never destroyed before the new one
+     * is committed.
+     */
+    private boolean commitAtomically(File tmp, File target, String key) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            try {
+                java.nio.file.Files.move(
+                    tmp.toPath(),
+                    target.toPath(),
+                    java.nio.file.StandardCopyOption.REPLACE_EXISTING,
+                    java.nio.file.StandardCopyOption.ATOMIC_MOVE);
+                return true;
+            } catch (Exception nioError) {
+                Log.w("StrataStorage", "Atomic NIO move failed, falling back for key " + key, nioError);
+                // fall through to the legacy strategy
+            }
+        }
+
+        // Direct rename — atomic replace on POSIX/ext4 internal storage.
+        if (tmp.renameTo(target)) {
+            return true;
+        }
+
+        // Rename-over-existing failed: move the old value aside first.
+        File backup = null;
+        if (target.exists()) {
+            backup = new File(stagingDir, UUID.randomUUID().toString() + ".bak");
+            if (!target.renameTo(backup)) {
+                // Could not preserve the old value — abort without data loss.
+                tmp.delete();
+                return false;
+            }
+        }
+
+        if (tmp.renameTo(target)) {
+            if (backup != null) {
+                backup.delete();
+            }
+            return true;
+        }
+
+        // New value did not land — restore the old value from backup.
+        if (backup != null && backup.renameTo(target)) {
+            Log.w("StrataStorage", "Restored previous value after failed write for key " + key);
+        }
+        tmp.delete();
+        return false;
+    }
+
     public synchronized boolean remove(String key) {
         File file = fileForKey(key);
         if (!file.exists()) {

package/android/src/main/java/com/strata/storage/SQLiteStorage.java

@@ -14,6 +14,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.regex.Pattern;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -47,6 +48,9 @@ public class SQLiteStorage extends SQLiteOpenHelper {
     private static final String KEY_TAGS = "tags";
     private static final String KEY_METADATA = "metadata";
 
+    /** Strict SQL-identifier allow-list for table names (cannot be bound). */
+    private static final Pattern IDENTIFIER = Pattern.compile("^[A-Za-z_][A-Za-z0-9_]*$");
+
     /** Tables already created in this DB during the process lifetime. */
     private final Set<String> ensuredTables = new HashSet<>();
 
@@ -60,16 +64,25 @@ public class SQLiteStorage extends SQLiteOpenHelper {
     }
 
     /**
-     * Sanitize a table name to a safe SQL identifier ({@code ^[A-Za-z0-9_]+$}).
-     * Table names cannot be passed as bound parameters in SQLite, so they MUST
-     * be validated before being interpolated into DDL/DML.
+     * Validate a table name as a strict SQL identifier
+     * ({@code ^[A-Za-z_][A-Za-z0-9_]*$}). Table names cannot be passed as bound
+     * parameters in SQLite, so they MUST be validated before being interpolated
+     * into DDL/DML. A null/empty name resolves to the default table; any other
+     * non-conforming name is REJECTED ({@link IllegalArgumentException}) rather
+     * than silently stripped — the TS adapter applies the same allow-list and
+     * rejects before the call ever reaches here, so this is defense-in-depth
+     * against a direct-plugin caller.
      */
     public static String sanitizeTable(String table) {
         if (table == null || table.isEmpty()) {
             return DEFAULT_TABLE;
         }
-        String cleaned = table.replaceAll("[^A-Za-z0-9_]", "");
-        return cleaned.isEmpty() ? DEFAULT_TABLE : cleaned;
+        if (!IDENTIFIER.matcher(table).matches()) {
+            throw new IllegalArgumentException(
+                    "Invalid SQLite table name: " + table
+                    + " (must match ^[A-Za-z_][A-Za-z0-9_]*$)");
+        }
+        return table;
     }
 
     @Override
@@ -209,17 +222,23 @@ public class SQLiteStorage extends SQLiteOpenHelper {
 
     public synchronized List<String> keys(String table, String pattern) {
         String safeTable = sanitizeTable(table);
+        long now = System.currentTimeMillis();
         List<String> keys = new ArrayList<>();
         SQLiteDatabase db = getReadableDatabase();
         ensureTable(db, safeTable);
         Cursor cursor = null;
+        // Exclude expired rows in SQL so the TS adapter does not need a per-key
+        // get() to drop them (eliminates the keys() N+1).
+        String notExpired = "(" + KEY_EXPIRES + " IS NULL OR " + KEY_EXPIRES + " > ?)";
+        String nowArg = String.valueOf(now);
         try {
             if (pattern != null) {
-                cursor = db.query(safeTable, new String[]{KEY_ID}, KEY_ID + " LIKE ?",
-                        new String[]{"%" + pattern + "%"}, null, null, null, null);
+                cursor = db.query(safeTable, new String[]{KEY_ID},
+                        KEY_ID + " LIKE ? AND " + notExpired,
+                        new String[]{"%" + pattern + "%", nowArg}, null, null, null, null);
             } else {
                 cursor = db.query(safeTable, new String[]{KEY_ID},
-                        null, null, null, null, null);
+                        notExpired, new String[]{nowArg}, null, null, null, null);
             }
             if (cursor != null && cursor.moveToFirst()) {
                 do {
@@ -251,23 +270,39 @@ public class SQLiteStorage extends SQLiteOpenHelper {
     }
 
     /**
-     * Enumerate every key in the table. The TS {@code SqliteAdapter} applies the
-     * real query condition by re-fetching/filtering each key, so this only needs
-     * to surface candidate keys.
+     * Enumerate non-expired rows as {@code { key, value }} where {@code value}
+     * is the full {@link StorageValue} wrapper (parsed from the stored JSON).
+     * Returning the wrapper here lets the TS {@code SqliteAdapter} run the real
+     * query condition in JS from a SINGLE round-trip instead of re-fetching
+     * each key (eliminates the query() N+1). Expired rows are filtered in SQL;
+     * an unparseable legacy payload surfaces as key-only (the TS side then
+     * falls back to {@code get()}, which treats it as a miss).
      */
     public synchronized List<Map<String, Object>> query(String table) {
         String safeTable = sanitizeTable(table);
+        long now = System.currentTimeMillis();
         List<Map<String, Object>> rows = new ArrayList<>();
         SQLiteDatabase db = getReadableDatabase();
         ensureTable(db, safeTable);
         Cursor cursor = null;
         try {
-            cursor = db.query(safeTable, new String[]{KEY_ID},
-                    null, null, null, null, null);
+            cursor = db.query(safeTable, new String[]{KEY_ID, KEY_VALUE},
+                    "(" + KEY_EXPIRES + " IS NULL OR " + KEY_EXPIRES + " > ?)",
+                    new String[]{String.valueOf(now)}, null, null, null, null);
             if (cursor != null && cursor.moveToFirst()) {
                 do {
                     Map<String, Object> row = new HashMap<>();
                     row.put("key", cursor.getString(0));
+                    String stored = cursor.getString(1);
+                    if (stored != null) {
+                        try {
+                            row.put("value", new JSObject(stored));
+                        } catch (JSONException parseError) {
+                            // Unparseable legacy payload: surface key only.
+                            Log.w("StrataStorage", "Unparseable SQLite value in query for key "
+                                    + cursor.getString(0));
+                        }
+                    }
                     rows.add(row);
                 } while (cursor.moveToNext());
             }
@@ -279,6 +314,23 @@ public class SQLiteStorage extends SQLiteOpenHelper {
         }
     }
 
+    /**
+     * Delete every expired row ({@code expires <= now}) in one statement and
+     * return the number removed. Because {@link #keys} and {@link #query} now
+     * filter expired rows in SQL (no lazy per-key deletion on read), this is
+     * what reclaims their physical storage; the TS adapter calls it on its TTL
+     * cleanup tick.
+     */
+    public synchronized int cleanupExpired(String table) {
+        String safeTable = sanitizeTable(table);
+        long now = System.currentTimeMillis();
+        SQLiteDatabase db = getWritableDatabase();
+        ensureTable(db, safeTable);
+        return db.delete(safeTable,
+                KEY_EXPIRES + " IS NOT NULL AND " + KEY_EXPIRES + " <= ?",
+                new String[]{String.valueOf(now)});
+    }
+
     /**
      * Size information. {@code total} = Σ(length(key) + length(value)), matching
      * the web adapters' convention (key bytes are included). When {@code

package/android/src/main/java/com/strata/storage/SharedPreferencesStorage.java

@@ -3,6 +3,7 @@ package com.strata.storage;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.util.Log;
+import java.lang.reflect.Array;
 import java.util.Map;
 import java.util.Set;
 import java.util.HashSet;
@@ -13,8 +14,8 @@ import org.json.JSONArray;
 
 public class SharedPreferencesStorage {
     private final SharedPreferences prefs;
-    private final SharedPreferences.Editor editor;
     private static final String DEFAULT_NAME = "StrataStorage";
+    private static final String KEY_PREFIX = "strata_storage::";
     
     public SharedPreferencesStorage(Context context) {
         this(context, DEFAULT_NAME);
@@ -22,21 +23,30 @@ public class SharedPreferencesStorage {
     
     public SharedPreferencesStorage(Context context, String name) {
         this.prefs = context.getSharedPreferences(name != null ? name : DEFAULT_NAME, Context.MODE_PRIVATE);
-        this.editor = prefs.edit();
     }
-    
-    public boolean set(String key, Object value) {
+
+    private String physicalKey(String key) {
+        return KEY_PREFIX + key;
+    }
+
+    private String logicalKey(String key) {
+        return key.startsWith(KEY_PREFIX) ? key.substring(KEY_PREFIX.length()) : key;
+    }
+
+    public synchronized boolean set(String key, Object value) {
         try {
+            SharedPreferences.Editor editor = prefs.edit();
+            String targetKey = physicalKey(key);
             if (value instanceof String) {
-                editor.putString(key, (String) value);
+                editor.putString(targetKey, (String) value);
             } else if (value instanceof Integer) {
-                editor.putInt(key, (Integer) value);
+                editor.putInt(targetKey, (Integer) value);
             } else if (value instanceof Long) {
-                editor.putLong(key, (Long) value);
+                editor.putLong(targetKey, (Long) value);
             } else if (value instanceof Float) {
-                editor.putFloat(key, (Float) value);
+                editor.putFloat(targetKey, (Float) value);
             } else if (value instanceof Boolean) {
-                editor.putBoolean(key, (Boolean) value);
+                editor.putBoolean(targetKey, (Boolean) value);
             } else if (value instanceof Set) {
                 // Safely convert to Set<String>
                 Set<?> rawSet = (Set<?>) value;
@@ -44,7 +54,7 @@ public class SharedPreferencesStorage {
                 for (Object item : rawSet) {
                     stringSet.add(item != null ? item.toString() : "null");
                 }
-                editor.putStringSet(key, stringSet);
+                editor.putStringSet(targetKey, stringSet);
             } else {
                 // Convert complex objects to JSON
                 String json;
@@ -59,7 +69,7 @@ public class SharedPreferencesStorage {
                         json = value.toString();
                     }
                 }
-                editor.putString(key, json);
+                editor.putString(targetKey, json);
             }
             return editor.commit();
         } catch (Exception e) {
@@ -68,13 +78,14 @@ public class SharedPreferencesStorage {
         }
     }
     
-    public Object get(String key) {
+    public synchronized Object get(String key) {
         Map<String, ?> all = prefs.getAll();
-        return all.get(key);
+        return all.get(physicalKey(key));
     }
-    
-    public boolean remove(String key) {
-        editor.remove(key);
+
+    public synchronized boolean remove(String key) {
+        SharedPreferences.Editor editor = prefs.edit();
+        editor.remove(physicalKey(key));
         return editor.commit();
     }
     
@@ -82,21 +93,20 @@ public class SharedPreferencesStorage {
         return clear(null);
     }
     
-    public boolean clear(String prefix) {
-        if (prefix != null) {
-            // Clear only keys with the given prefix
-            Set<String> keysToRemove = new HashSet<>();
-            for (String key : prefs.getAll().keySet()) {
-                if (key.startsWith(prefix) || key.contains(prefix)) {
-                    keysToRemove.add(key);
-                }
+    public synchronized boolean clear(String prefix) {
+        Set<String> keysToRemove = new HashSet<>();
+        for (String key : prefs.getAll().keySet()) {
+            if (!key.startsWith(KEY_PREFIX)) {
+                continue;
             }
-            for (String key : keysToRemove) {
-                editor.remove(key);
+            String logical = logicalKey(key);
+            if (prefix == null || logical.startsWith(prefix) || logical.contains(prefix)) {
+                keysToRemove.add(key);
             }
-        } else {
-            // Clear all keys
-            editor.clear();
+        }
+        SharedPreferences.Editor editor = prefs.edit();
+        for (String key : keysToRemove) {
+            editor.remove(key);
         }
         return editor.commit();
     }
@@ -106,37 +116,38 @@ public class SharedPreferencesStorage {
     }
     
     public List<String> keys(String pattern) {
-        Set<String> allKeys = prefs.getAll().keySet();
-        
-        if (pattern == null) {
-            return new ArrayList<>(allKeys);
-        }
-        
-        // Filter keys by pattern
-        List<String> filteredKeys = new ArrayList<>();
-        for (String key : allKeys) {
-            if (key.startsWith(pattern) || key.contains(pattern)) {
-                filteredKeys.add(key);
+        List<String> keys = new ArrayList<>();
+        for (String physical : prefs.getAll().keySet()) {
+            if (!physical.startsWith(KEY_PREFIX)) {
+                continue;
+            }
+            String key = logicalKey(physical);
+            if (pattern == null || key.startsWith(pattern) || key.contains(pattern)) {
+                keys.add(key);
             }
         }
-        return filteredKeys;
+        return keys;
     }
-    
-    public boolean has(String key) {
-        return prefs.contains(key);
+
+    public synchronized boolean has(String key) {
+        return prefs.contains(physicalKey(key));
     }
     
     public Map<String, ?> getAll() {
         return prefs.getAll();
     }
     
-    public SizeInfo size() {
+    public synchronized SizeInfo size() {
         Map<String, ?> all = prefs.getAll();
         long totalSize = 0;
-        int count = all.size();
-        
+        int count = 0;
+
         for (Map.Entry<String, ?> entry : all.entrySet()) {
-            String key = entry.getKey();
+            String physical = entry.getKey();
+            if (!physical.startsWith(KEY_PREFIX)) {
+                continue;
+            }
+            String key = logicalKey(physical);
             Object value = entry.getValue();
             
             // Estimate size (key + value in bytes)
@@ -144,6 +155,7 @@ public class SharedPreferencesStorage {
             if (value != null) {
                 totalSize += value.toString().getBytes().length;
             }
+            count++;
         }
         
         return new SizeInfo(totalSize, count);
@@ -179,9 +191,9 @@ public class SharedPreferencesStorage {
                     jsonArray.put(item);
                 }
             } else {
-                Object[] array = (Object[]) obj;
-                for (Object item : array) {
-                    jsonArray.put(item);
+                int len = Array.getLength(obj);
+                for (int i = 0; i < len; i++) {
+                    jsonArray.put(Array.get(obj, i));
                 }
             }
             return jsonArray.toString();

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

@@ -12,9 +12,11 @@ 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;
+import java.util.regex.Pattern;
 
 /**
  * Main Capacitor plugin for Strata Storage
@@ -32,6 +34,9 @@ public class StrataStoragePlugin extends Plugin {
     private static final String DEFAULT_DATABASE = "strata_storage";
     private static final String DEFAULT_TABLE = "storage";
 
+    /** Strict SQL-identifier allow-list for the database file stem. */
+    private static final Pattern SQLITE_IDENTIFIER = Pattern.compile("^[A-Za-z_][A-Za-z0-9_]*$");
+
     private SharedPreferencesStorage sharedPrefsStorage;
     private EncryptedStorage encryptedStorage;
     private FilesystemStorage filesystemStorage;
@@ -61,25 +66,37 @@ public class StrataStoragePlugin extends Plugin {
     }
 
     /**
-     * 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.
+     * Validate a database name as a strict SQL identifier
+     * ({@code ^[A-Za-z_][A-Za-z0-9_]*$}) and return it as the file stem. The
+     * ".db" suffix is appended when opening. A null/empty name resolves to the
+     * default; any other non-conforming name is REJECTED rather than silently
+     * stripped (the TS adapter applies the same allow-list and rejects first —
+     * this is defense-in-depth, and also blocks path separators / traversal).
      */
     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;
+        if (!SQLITE_IDENTIFIER.matcher(database).matches()) {
+            throw new IllegalArgumentException("Invalid SQLite database name: " + database);
+        }
+        return database;
     }
 
     /**
      * 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.
+     * database name. The cache is keyed by the validated DB stem so the
+     * connection is reused across bridge calls. Returns {@code null} if the name
+     * is invalid or the helper cannot be constructed — callers reject the call.
      */
     private synchronized SQLiteStorage getSqliteStore(String database) {
-        String dbStem = sanitizeDatabase(database);
+        final String dbStem;
+        try {
+            dbStem = sanitizeDatabase(database);
+        } catch (IllegalArgumentException e) {
+            Log.e("StrataStorage", "Invalid SQLite database name", e);
+            return null;
+        }
         SQLiteStorage store = sqliteStores.get(dbStem);
         if (store == null) {
             try {
@@ -189,12 +206,32 @@ public class StrataStoragePlugin extends Plugin {
         JSObject result = new JSObject();
         if (value == null) {
             result.put("value", JSObject.NULL);
+        } else if (value instanceof String) {
+            // preferences/secure persist the full StorageValue wrapper as a JSON
+            // string; parse it back to an object so TTL/tags/metadata round-trip
+            // (matching the sqlite/filesystem contract). Legacy/plain strings are
+            // returned unchanged.
+            result.put("value", parseWrapperOrRaw((String) value));
         } else {
             result.put("value", value);
         }
         call.resolve(result);
     }
 
+    /** Parse a stored JSON-object wrapper string back into a {@link JSObject};
+     * return the raw string for non-JSON-object payloads. */
+    private Object parseWrapperOrRaw(String raw) {
+        String trimmed = raw.trim();
+        if (trimmed.startsWith("{")) {
+            try {
+                return new JSObject(raw);
+            } catch (JSONException ignored) {
+                // Not a JSON object — fall through and return the raw string.
+            }
+        }
+        return raw;
+    }
+
     /**
      * Set value in storage.
      *
@@ -513,9 +550,10 @@ public class StrataStoragePlugin extends Plugin {
 
     /**
      * 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.
+     * Matches the optional `query` method in the JS contract: resolves
+     * { results: [{ key, value }] } where `value` is the full StorageValue
+     * wrapper for each non-expired row, so the JS SqliteAdapter can apply the
+     * condition in one round-trip without re-fetching each key.
      */
     @PluginMethod
     public void query(PluginCall call) {
@@ -536,6 +574,10 @@ public class StrataStoragePlugin extends Plugin {
             for (Map<String, Object> row : rows) {
                 JSObject obj = new JSObject();
                 obj.put("key", row.get("key"));
+                Object value = row.get("value");
+                if (value != null) {
+                    obj.put("value", value);
+                }
                 results.put(obj);
             }
             JSObject result = new JSObject();
@@ -546,6 +588,33 @@ public class StrataStoragePlugin extends Plugin {
         }
     }
 
+    /**
+     * Delete every expired row for a SQLite store in one statement and resolve
+     * { removed: <count> }. The JS adapter calls this on its TTL cleanup tick,
+     * since keys()/query() now exclude expired rows in SQL (no per-key delete).
+     */
+    @PluginMethod
+    public void cleanupExpired(PluginCall call) {
+        String storage = call.getString("storage", "sqlite");
+        if (!"sqlite".equals(storage)) {
+            call.reject("cleanupExpired 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 {
+            int removed = store.cleanupExpired(call.getString("table", DEFAULT_TABLE));
+            JSObject result = new JSObject();
+            result.put("removed", removed);
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Failed to clean up expired SQLite rows", e);
+        }
+    }
+
     /**
      * Android-specific: read an encrypted preference.
      * Resolves { value: unknown }. Honors an optional `fileName`.