strata-storage 2.4.3 → 2.6.0

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

@@ -1,24 +1,44 @@
 package com.strata.storage;
 
 import android.content.Context;
+import android.content.ContentValues;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
-import android.content.ContentValues;
 import android.util.Log;
+import com.getcapacitor.JSObject;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.List;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import org.json.JSONException;
 import org.json.JSONObject;
-import org.json.JSONArray;
-import java.nio.charset.StandardCharsets;
 
+/**
+ * SQLite-backed storage. One {@link SQLiteStorage} instance maps to a single
+ * database file (one {@link SQLiteOpenHelper}). A single instance can serve
+ * multiple logical tables: every public method takes a sanitized {@code table}
+ * name and the table is created on first use via {@code CREATE TABLE IF NOT
+ * EXISTS}.
+ *
+ * <p>Value-shape contract (matches the TS {@code SqliteAdapter}): {@code set}
+ * receives the FULL wrapper object ({@code value, created, updated, expires?,
+ * tags?, metadata?}). The entire wrapper is JSON-serialized into the
+ * {@code value} column for round-trip fidelity, while {@code created},
+ * {@code updated}, {@code expires}, {@code tags} and {@code metadata} are also
+ * extracted into their own columns for TTL + query support. {@code get} parses
+ * the {@code value} column back into a {@link JSObject} wrapper.
+ *
+ * <p>All database access is synchronized on the instance so overlapping bridge
+ * calls cannot corrupt the connection.
+ */
 public class SQLiteStorage extends SQLiteOpenHelper {
     private static final int DATABASE_VERSION = 1;
-    private static final String TABLE_NAME = "strata_storage";
-    private static final String DEFAULT_DB_NAME = "strata.db";
-    
+    private static final String DEFAULT_TABLE = "storage";
+
     private static final String KEY_ID = "key";
     private static final String KEY_VALUE = "value";
     private static final String KEY_CREATED = "created";
@@ -26,178 +46,181 @@ public class SQLiteStorage extends SQLiteOpenHelper {
     private static final String KEY_EXPIRES = "expires";
     private static final String KEY_TAGS = "tags";
     private static final String KEY_METADATA = "metadata";
-    
-    public SQLiteStorage(Context context) {
-        this(context, DEFAULT_DB_NAME);
-    }
-    
+
+    /** Tables already created in this DB during the process lifetime. */
+    private final Set<String> ensuredTables = new HashSet<>();
+
+    /**
+     * @param context  Android context
+     * @param dbName    fully-resolved database file name (already sanitized +
+     *                  suffixed with ".db" by the plugin)
+     */
     public SQLiteStorage(Context context, String dbName) {
-        super(context, dbName != null ? dbName : DEFAULT_DB_NAME, null, DATABASE_VERSION);
+        super(context, dbName, null, DATABASE_VERSION);
+    }
+
+    /**
+     * 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.
+     */
+    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;
     }
-    
+
     @Override
     public void onCreate(SQLiteDatabase db) {
-        String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + "("
+        // Tables are created lazily per (database, table) via ensureTable().
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        // No destructive migrations: tables are created on demand and persist.
+    }
+
+    /**
+     * Create the table for {@code safeTable} if it does not yet exist. Caller
+     * MUST pass an already-sanitized identifier.
+     */
+    private void ensureTable(SQLiteDatabase db, String safeTable) {
+        if (ensuredTables.contains(safeTable)) {
+            return;
+        }
+        String createTable = "CREATE TABLE IF NOT EXISTS " + safeTable + "("
                 + KEY_ID + " TEXT PRIMARY KEY,"
-                + KEY_VALUE + " BLOB NOT NULL,"
+                + KEY_VALUE + " TEXT NOT NULL,"
                 + KEY_CREATED + " INTEGER NOT NULL,"
                 + KEY_UPDATED + " INTEGER NOT NULL,"
                 + KEY_EXPIRES + " INTEGER,"
                 + KEY_TAGS + " TEXT,"
                 + KEY_METADATA + " TEXT" + ")";
-        db.execSQL(CREATE_TABLE);
-    }
-    
-    @Override
-    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
-        onCreate(db);
+        db.execSQL(createTable);
+        ensuredTables.add(safeTable);
     }
-    
-    public boolean set(String key, Object value, Long expires, String tags, String metadata) {
-        byte[] valueBytes;
-        
-        try {
-            if (value instanceof byte[]) {
-                valueBytes = (byte[]) value;
-            } else if (value instanceof String) {
-                valueBytes = ((String) value).getBytes(StandardCharsets.UTF_8);
-            } else {
-                // Convert complex objects to JSON then to bytes
-                String json;
-                if (value instanceof JSONObject) {
-                    json = ((JSONObject) value).toString();
-                } else {
-                    // Use helper method to convert object to JSON string
-                    try {
-                        json = objectToJsonString(value);
-                    } catch (Exception jsonEx) {
-                        // Fallback to string representation
-                        json = value.toString();
-                    }
-                }
-                valueBytes = json.getBytes(StandardCharsets.UTF_8);
-            }
-        } catch (Exception e) {
-            Log.e("StrataStorage", "Failed to set value in SQLite", e);
+
+    /**
+     * Persist the full wrapper for {@code key}. The wrapper is stored verbatim
+     * as JSON in the {@code value} column; {@code created}/{@code updated}/
+     * {@code expires}/{@code tags}/{@code metadata} are mirrored into columns
+     * for TTL + query.
+     *
+     * @param wrapper the full {@link StorageValue} wrapper as a {@link JSObject}
+     */
+    public synchronized boolean set(String table, String key, JSObject wrapper) {
+        if (wrapper == null) {
             return false;
         }
-        SQLiteDatabase db = this.getWritableDatabase();
-        ContentValues values = new ContentValues();
-        
+        String safeTable = sanitizeTable(table);
         long now = System.currentTimeMillis();
+
+        // Column extraction for TTL + query. Defaults keep legacy fidelity.
+        long created = wrapper.optLong(KEY_CREATED, now);
+        long updated = wrapper.optLong(KEY_UPDATED, now);
+
+        ContentValues values = new ContentValues();
         values.put(KEY_ID, key);
-        values.put(KEY_VALUE, valueBytes);
-        values.put(KEY_CREATED, now);
-        values.put(KEY_UPDATED, now);
-        
-        if (expires != null) {
-            values.put(KEY_EXPIRES, expires);
+        values.put(KEY_VALUE, wrapper.toString());
+        values.put(KEY_CREATED, created);
+        values.put(KEY_UPDATED, updated);
+
+        if (wrapper.has(KEY_EXPIRES) && !wrapper.isNull(KEY_EXPIRES)) {
+            values.put(KEY_EXPIRES, wrapper.optLong(KEY_EXPIRES));
         }
-        if (tags != null) {
-            values.put(KEY_TAGS, tags);
+        // tags / metadata are stored as their JSON text for query use.
+        Object tags = wrapper.opt(KEY_TAGS);
+        if (tags != null && tags != JSONObject.NULL) {
+            values.put(KEY_TAGS, tags.toString());
         }
-        if (metadata != null) {
-            values.put(KEY_METADATA, metadata);
+        Object metadata = wrapper.opt(KEY_METADATA);
+        if (metadata != null && metadata != JSONObject.NULL) {
+            values.put(KEY_METADATA, metadata.toString());
+        }
+
+        try {
+            SQLiteDatabase db = getWritableDatabase();
+            ensureTable(db, safeTable);
+            long result = db.insertWithOnConflict(
+                    safeTable, null, values, SQLiteDatabase.CONFLICT_REPLACE);
+            return result != -1;
+        } catch (Exception e) {
+            Log.e("StrataStorage", "Failed to set value in SQLite", e);
+            return false;
         }
-        
-        long result = db.insertWithOnConflict(TABLE_NAME, null, values, SQLiteDatabase.CONFLICT_REPLACE);
-        db.close();
-        return result != -1;
-    }
-    
-    // Convenience method for simple Object values
-    public boolean set(String key, Object value) {
-        return set(key, value, null, null, null);
     }
-    
-    public Map<String, Object> get(String key) {
-        SQLiteDatabase db = this.getReadableDatabase();
+
+    /**
+     * Read the full wrapper for {@code key}, parsed back from the JSON stored in
+     * the {@code value} column. Missing row → {@code null}. Unparseable legacy
+     * bytes → {@code null} (treated as a miss; never throws).
+     */
+    public synchronized JSObject get(String table, String key) {
+        String safeTable = sanitizeTable(table);
+        SQLiteDatabase db = getReadableDatabase();
+        ensureTable(db, safeTable);
         Cursor cursor = null;
         try {
-            cursor = db.query(TABLE_NAME, null, KEY_ID + "=?",
+            cursor = db.query(safeTable, new String[]{KEY_VALUE}, KEY_ID + "=?",
                     new String[]{key}, null, null, null, null);
-
-            Map<String, Object> result = null;
             if (cursor != null && cursor.moveToFirst()) {
-                result = new HashMap<>();
-                result.put("key", key);
-                result.put("value", cursor.getBlob(cursor.getColumnIndex(KEY_VALUE)));
-                result.put("created", cursor.getLong(cursor.getColumnIndex(KEY_CREATED)));
-                result.put("updated", cursor.getLong(cursor.getColumnIndex(KEY_UPDATED)));
-
-                int expiresIndex = cursor.getColumnIndex(KEY_EXPIRES);
-                if (!cursor.isNull(expiresIndex)) {
-                    result.put("expires", cursor.getLong(expiresIndex));
-                }
-
-                int tagsIndex = cursor.getColumnIndex(KEY_TAGS);
-                if (!cursor.isNull(tagsIndex)) {
-                    result.put("tags", cursor.getString(tagsIndex));
+                String stored = cursor.getString(0);
+                if (stored == null) {
+                    return null;
                 }
-
-                int metadataIndex = cursor.getColumnIndex(KEY_METADATA);
-                if (!cursor.isNull(metadataIndex)) {
-                    result.put("metadata", cursor.getString(metadataIndex));
+                try {
+                    return new JSObject(stored);
+                } catch (JSONException parseError) {
+                    // Legacy / corrupted payload: treat as a miss rather than throw.
+                    Log.w("StrataStorage", "Unparseable SQLite value for key " + key);
+                    return null;
                 }
             }
-            return result;
+            return null;
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
-            db.close();
         }
     }
-    
-    public boolean remove(String key) {
-        SQLiteDatabase db = this.getWritableDatabase();
-        int result = db.delete(TABLE_NAME, KEY_ID + " = ?", new String[]{key});
-        db.close();
+
+    public synchronized boolean remove(String table, String key) {
+        String safeTable = sanitizeTable(table);
+        SQLiteDatabase db = getWritableDatabase();
+        ensureTable(db, safeTable);
+        int result = db.delete(safeTable, KEY_ID + " = ?", new String[]{key});
         return result > 0;
     }
-    
-    public boolean clear() {
-        return clear(null);
-    }
-    
-    public boolean clear(String prefix) {
-        SQLiteDatabase db = this.getWritableDatabase();
+
+    public synchronized boolean clear(String table, String prefix) {
+        String safeTable = sanitizeTable(table);
+        SQLiteDatabase db = getWritableDatabase();
+        ensureTable(db, safeTable);
         int result;
-        
         if (prefix != null) {
-            // Clear only keys with the given prefix
-            result = db.delete(TABLE_NAME, KEY_ID + " LIKE ?", new String[]{prefix + "%"});
+            result = db.delete(safeTable, KEY_ID + " LIKE ?", new String[]{prefix + "%"});
         } else {
-            // Clear all keys
-            result = db.delete(TABLE_NAME, null, null);
+            result = db.delete(safeTable, null, null);
         }
-        
-        db.close();
         return result >= 0;
     }
-    
-    public List<String> keys() {
-        return keys(null);
-    }
-    
-    public List<String> keys(String pattern) {
-        List<String> keys = new ArrayList<>();
-        String selectQuery;
-        String[] selectionArgs = null;
 
-        if (pattern != null) {
-            selectQuery = "SELECT " + KEY_ID + " FROM " + TABLE_NAME + " WHERE " + KEY_ID + " LIKE ?";
-            selectionArgs = new String[]{"%" + pattern + "%"};
-        } else {
-            selectQuery = "SELECT " + KEY_ID + " FROM " + TABLE_NAME;
-        }
-
-        SQLiteDatabase db = this.getReadableDatabase();
+    public synchronized List<String> keys(String table, String pattern) {
+        String safeTable = sanitizeTable(table);
+        List<String> keys = new ArrayList<>();
+        SQLiteDatabase db = getReadableDatabase();
+        ensureTable(db, safeTable);
         Cursor cursor = null;
         try {
-            cursor = db.rawQuery(selectQuery, selectionArgs);
-
+            if (pattern != null) {
+                cursor = db.query(safeTable, new String[]{KEY_ID}, KEY_ID + " LIKE ?",
+                        new String[]{"%" + pattern + "%"}, null, null, null, null);
+            } else {
+                cursor = db.query(safeTable, new String[]{KEY_ID},
+                        null, null, null, null, null);
+            }
             if (cursor != null && cursor.moveToFirst()) {
                 do {
                     keys.add(cursor.getString(0));
@@ -208,107 +231,141 @@ public class SQLiteStorage extends SQLiteOpenHelper {
             if (cursor != null) {
                 cursor.close();
             }
-            db.close();
         }
     }
-    
-    public boolean has(String key) {
-        SQLiteDatabase db = this.getReadableDatabase();
+
+    public synchronized boolean has(String table, String key) {
+        String safeTable = sanitizeTable(table);
+        SQLiteDatabase db = getReadableDatabase();
+        ensureTable(db, safeTable);
         Cursor cursor = null;
         try {
-            cursor = db.query(TABLE_NAME, new String[]{KEY_ID}, KEY_ID + "=?",
+            cursor = db.query(safeTable, new String[]{KEY_ID}, KEY_ID + "=?",
                     new String[]{key}, null, null, null, null);
-            boolean exists = cursor != null && cursor.getCount() > 0;
-            return exists;
+            return cursor != null && cursor.getCount() > 0;
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
-            db.close();
         }
     }
-    
-    public SizeInfo size() {
-        SQLiteDatabase db = this.getReadableDatabase();
+
+    /**
+     * 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.
+     */
+    public synchronized List<Map<String, Object>> query(String table) {
+        String safeTable = sanitizeTable(table);
+        List<Map<String, Object>> rows = new ArrayList<>();
+        SQLiteDatabase db = getReadableDatabase();
+        ensureTable(db, safeTable);
         Cursor cursor = null;
         try {
-            cursor = db.rawQuery("SELECT COUNT(*), SUM(LENGTH(" + KEY_VALUE + ")) FROM " + TABLE_NAME, null);
-
-            long totalSize = 0;
-            int count = 0;
-
+            cursor = db.query(safeTable, new String[]{KEY_ID},
+                    null, null, null, null, null);
             if (cursor != null && cursor.moveToFirst()) {
-                count = cursor.getInt(0);
-                // Check for NULL values from SQL SUM function
-                if (!cursor.isNull(1)) {
-                    totalSize = cursor.getLong(1);
-                }
+                do {
+                    Map<String, Object> row = new HashMap<>();
+                    row.put("key", cursor.getString(0));
+                    rows.add(row);
+                } while (cursor.moveToNext());
             }
-
-            return new SizeInfo(totalSize, count);
+            return rows;
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
-            db.close();
         }
     }
-    
+
     /**
-     * Convert an object to JSON string using reflection
+     * Size information. {@code total} = Σ(length(key) + length(value)), matching
+     * the web adapters' convention (key bytes are included). When {@code
+     * detailed} is true the byte breakdown is also populated: {@code keys} = Σ
+     * length(key), {@code values} = Σ length(value), {@code metadata} = Σ
+     * length(metadata) (0 for null); {@code count} is the row count.
      */
-    private String objectToJsonString(Object obj) throws Exception {
-        if (obj == null) {
-            return "null";
-        }
-        
-        if (obj instanceof String || obj instanceof Number || obj instanceof Boolean) {
-            return obj.toString();
-        }
-        
-        if (obj instanceof Map) {
-            JSONObject jsonObj = new JSONObject();
-            Map<?, ?> map = (Map<?, ?>) obj;
-            for (Map.Entry<?, ?> entry : map.entrySet()) {
-                String key = entry.getKey().toString();
-                jsonObj.put(key, entry.getValue());
-            }
-            return jsonObj.toString();
-        }
-        
-        if (obj instanceof List || obj.getClass().isArray()) {
-            JSONArray jsonArray = new JSONArray();
-            if (obj instanceof List) {
-                List<?> list = (List<?>) obj;
-                for (Object item : list) {
-                    jsonArray.put(item);
-                }
-            } else {
-                Object[] array = (Object[]) obj;
-                for (Object item : array) {
-                    jsonArray.put(item);
+    public synchronized SizeInfo size(String table, boolean detailed) {
+        String safeTable = sanitizeTable(table);
+        SQLiteDatabase db = getReadableDatabase();
+        ensureTable(db, safeTable);
+        Cursor cursor = null;
+        try {
+            if (!detailed) {
+                cursor = db.rawQuery("SELECT COUNT(*), SUM(LENGTH(" + KEY_ID + ") + LENGTH("
+                        + KEY_VALUE + ")) FROM " + safeTable, null);
+                long totalSize = 0;
+                int count = 0;
+                if (cursor != null && cursor.moveToFirst()) {
+                    count = cursor.getInt(0);
+                    if (!cursor.isNull(1)) {
+                        totalSize = cursor.getLong(1);
+                    }
                 }
+                return new SizeInfo(totalSize, count);
+            }
+
+            cursor = db.query(safeTable,
+                    new String[]{KEY_ID, KEY_VALUE, KEY_METADATA},
+                    null, null, null, null, null);
+            long keysBytes = 0;
+            long valuesBytes = 0;
+            long metadataBytes = 0;
+            int count = 0;
+            if (cursor != null && cursor.moveToFirst()) {
+                do {
+                    count++;
+                    String key = cursor.getString(0);
+                    String value = cursor.getString(1);
+                    String metadata = cursor.getString(2);
+                    if (key != null) {
+                        keysBytes += key.getBytes(StandardCharsets.UTF_8).length;
+                    }
+                    if (value != null) {
+                        valuesBytes += value.getBytes(StandardCharsets.UTF_8).length;
+                    }
+                    if (metadata != null) {
+                        metadataBytes += metadata.getBytes(StandardCharsets.UTF_8).length;
+                    }
+                } while (cursor.moveToNext());
+            }
+            return new SizeInfo(keysBytes + valuesBytes, count, keysBytes, valuesBytes, metadataBytes);
+        } finally {
+            if (cursor != null) {
+                cursor.close();
             }
-            return jsonArray.toString();
         }
-        
-        // For other objects, create a simple JSON object with their string representation
-        JSONObject jsonObj = new JSONObject();
-        jsonObj.put("value", obj.toString());
-        jsonObj.put("type", obj.getClass().getSimpleName());
-        return jsonObj.toString();
     }
-    
+
     /**
-     * Size information class
+     * Size information. The detailed byte breakdown is only meaningful when
+     * {@link #detailed} is true.
      */
     public static class SizeInfo {
         public final long total;
         public final int count;
-        
+        public final boolean detailed;
+        public final long keysBytes;
+        public final long valuesBytes;
+        public final long metadataBytes;
+
         public SizeInfo(long total, int count) {
             this.total = total;
             this.count = count;
+            this.detailed = false;
+            this.keysBytes = 0;
+            this.valuesBytes = 0;
+            this.metadataBytes = 0;
+        }
+
+        public SizeInfo(long total, int count, long keysBytes, long valuesBytes, long metadataBytes) {
+            this.total = total;
+            this.count = count;
+            this.detailed = true;
+            this.keysBytes = keysBytes;
+            this.valuesBytes = valuesBytes;
+            this.metadataBytes = metadataBytes;
         }
     }
-}
+}