strata-storage 2.6.1 → 2.7.1

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

@@ -1,287 +0,0 @@
-package com.strata.storage;
-
-import android.content.Context;
-import android.util.Log;
-import com.getcapacitor.JSObject;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.net.URLDecoder;
-import java.net.URLEncoder;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
-import org.json.JSONException;
-
-/**
- * Filesystem-backed storage. One file per key lives under
- * {@code <filesDir>/strata_storage}. The file name is a reversible
- * URL-encoding of the key (no path separators survive encoding) and the file
- * contents are the JSON-serialized FULL wrapper object ({@code value, created,
- * updated, expires?, tags?, metadata?}), mirroring the SQLite value-shape
- * contract.
- *
- * <p>Writes are atomic: a temp file is written then renamed over the target.
- * All access is synchronized on the instance so overlapping bridge calls are
- * safe.
- */
-public class FilesystemStorage {
-    private static final String DIR_NAME = "strata_storage";
-    private static final String ENCODING = "UTF-8";
-    /**
-     * Reserved subdirectory (inside the storage dir) that holds in-flight temp
-     * files for atomic writes. Because it is a directory, the file-only
-     * enumeration in keys()/size()/clear() skips it automatically, and temp
-     * names therefore can never collide with an encoded key file in the storage
-     * dir (e.g. a real key {@code "backup.tmp"}).
-     */
-    private static final String STAGING_DIR_NAME = ".strata-staging";
-
-    private final File baseDir;
-    private final File stagingDir;
-
-    public FilesystemStorage(Context context) {
-        this.baseDir = new File(context.getFilesDir(), DIR_NAME);
-        this.stagingDir = new File(baseDir, STAGING_DIR_NAME);
-        ensureDir();
-    }
-
-    private synchronized void ensureDir() {
-        if (!baseDir.exists()) {
-            // mkdirs() returns false if it already exists due to a race; the
-            // subsequent exists() check below is the real guard.
-            baseDir.mkdirs();
-        }
-        if (!stagingDir.exists()) {
-            stagingDir.mkdirs();
-        }
-    }
-
-    /** Reversibly encode a key into a path-separator-free file name. */
-    private static String encodeKey(String key) {
-        try {
-            return URLEncoder.encode(key, ENCODING);
-        } catch (Exception e) {
-            // UTF-8 is always supported; fall back defensively.
-            return key.replaceAll("[^A-Za-z0-9_-]", "_");
-        }
-    }
-
-    /** Inverse of {@link #encodeKey(String)}. */
-    private static String decodeKey(String fileName) {
-        try {
-            return URLDecoder.decode(fileName, ENCODING);
-        } catch (Exception e) {
-            return fileName;
-        }
-    }
-
-    private File fileForKey(String key) {
-        return new File(baseDir, encodeKey(key));
-    }
-
-    /**
-     * Read + parse the full wrapper for {@code key}. Missing file → {@code null}.
-     * Unparseable contents → {@code null} (treated as a miss; never throws).
-     */
-    public synchronized JSObject get(String key) {
-        File file = fileForKey(key);
-        if (!file.exists() || !file.isFile()) {
-            return null;
-        }
-        try {
-            String json = readFile(file);
-            return new JSObject(json);
-        } catch (JSONException parseError) {
-            Log.w("StrataStorage", "Unparseable filesystem value for key " + key);
-            return null;
-        } catch (IOException ioError) {
-            Log.e("StrataStorage", "Failed to read filesystem value for key " + key, ioError);
-            return null;
-        }
-    }
-
-    /**
-     * Atomically persist the full wrapper for {@code key}: write a temp file
-     * then rename it over the destination.
-     */
-    public synchronized boolean set(String key, JSObject wrapper) {
-        if (wrapper == null) {
-            return false;
-        }
-        ensureDir();
-        File target = fileForKey(key);
-        // Temp file lives in the staging subdir (same filesystem → atomic
-        // rename) with a UUID name, so it can never collide with a key file.
-        File tmp = new File(stagingDir, UUID.randomUUID().toString() + ".tmp");
-        FileOutputStream fos = null;
-        try {
-            fos = new FileOutputStream(tmp);
-            fos.write(wrapper.toString().getBytes(StandardCharsets.UTF_8));
-            fos.flush();
-            fos.getFD().sync();
-            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;
-        } catch (IOException e) {
-            Log.e("StrataStorage", "Failed to set filesystem value for key " + key, e);
-            if (tmp.exists()) {
-                tmp.delete();
-            }
-            return false;
-        } finally {
-            if (fos != null) {
-                try {
-                    fos.close();
-                } catch (IOException ignored) {
-                    // best-effort close
-                }
-            }
-        }
-    }
-
-    public synchronized boolean remove(String key) {
-        File file = fileForKey(key);
-        if (!file.exists()) {
-            return false;
-        }
-        return file.delete();
-    }
-
-    /**
-     * Delete all stored entries. {@code prefix}, when non-null, restricts the
-     * delete to keys whose (decoded) name starts with the prefix.
-     */
-    public synchronized boolean clear(String prefix) {
-        File[] files = baseDir.listFiles();
-        if (files == null) {
-            return true;
-        }
-        boolean ok = true;
-        for (File file : files) {
-            // Skips the staging subdirectory (and any other non-file entry).
-            if (!file.isFile()) {
-                continue;
-            }
-            if (prefix == null || decodeKey(file.getName()).startsWith(prefix)) {
-                if (!file.delete()) {
-                    ok = false;
-                }
-            }
-        }
-        // On a full clear, also drop any orphaned in-flight temp files.
-        if (prefix == null) {
-            File[] temps = stagingDir.listFiles();
-            if (temps != null) {
-                for (File t : temps) {
-                    t.delete();
-                }
-            }
-        }
-        return ok;
-    }
-
-    public synchronized List<String> keys(String pattern) {
-        List<String> keys = new ArrayList<>();
-        File[] files = baseDir.listFiles();
-        if (files == null) {
-            return keys;
-        }
-        for (File file : files) {
-            // Skips the staging subdirectory (and any other non-file entry).
-            if (!file.isFile()) {
-                continue;
-            }
-            String key = decodeKey(file.getName());
-            if (pattern == null || key.contains(pattern)) {
-                keys.add(key);
-            }
-        }
-        return keys;
-    }
-
-    public synchronized boolean has(String key) {
-        File file = fileForKey(key);
-        return file.exists() && file.isFile();
-    }
-
-    /**
-     * Size information. {@code total} = {@code keys} + {@code values} (matching
-     * the web adapters' convention), {@code values} = Σ file byte sizes,
-     * {@code keys} = Σ decoded-key byte lengths, {@code metadata} = Σ length of
-     * the parsed {@code metadata} field (0 when absent or unparseable),
-     * {@code count} = number of stored files. The detailed breakdown is only
-     * surfaced to JS when {@code detailed} is true.
-     */
-    public synchronized SQLiteStorage.SizeInfo size(boolean detailed) {
-        File[] files = baseDir.listFiles();
-        long valuesBytes = 0;
-        long keysBytes = 0;
-        long metadataBytes = 0;
-        int count = 0;
-
-        if (files != null) {
-            for (File file : files) {
-                // Skips the staging subdirectory (and any other non-file entry).
-                if (!file.isFile()) {
-                    continue;
-                }
-                count++;
-                valuesBytes += file.length();
-                keysBytes += decodeKey(file.getName()).getBytes(StandardCharsets.UTF_8).length;
-                if (detailed) {
-                    metadataBytes += metadataByteLength(file);
-                }
-            }
-        }
-
-        if (!detailed) {
-            return new SQLiteStorage.SizeInfo(keysBytes + valuesBytes, count);
-        }
-        return new SQLiteStorage.SizeInfo(keysBytes + valuesBytes, count, keysBytes, valuesBytes, metadataBytes);
-    }
-
-    /** Parse the file and return the byte length of its {@code metadata} field. */
-    private long metadataByteLength(File file) {
-        try {
-            JSObject wrapper = new JSObject(readFile(file));
-            Object metadata = wrapper.opt("metadata");
-            if (metadata != null && metadata != org.json.JSONObject.NULL) {
-                return metadata.toString().getBytes(StandardCharsets.UTF_8).length;
-            }
-        } catch (Exception ignored) {
-            // Unparseable → contributes 0 metadata bytes.
-        }
-        return 0;
-    }
-
-    private String readFile(File file) throws IOException {
-        byte[] data = new byte[(int) file.length()];
-        java.io.FileInputStream fis = null;
-        try {
-            fis = new java.io.FileInputStream(file);
-            int offset = 0;
-            int read;
-            while (offset < data.length
-                    && (read = fis.read(data, offset, data.length - offset)) != -1) {
-                offset += read;
-            }
-        } finally {
-            if (fis != null) {
-                fis.close();
-            }
-        }
-        return new String(data, StandardCharsets.UTF_8);
-    }
-}

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

@@ -1,371 +0,0 @@
-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.util.Log;
-import com.getcapacitor.JSObject;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-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;
-
-/**
- * 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 DEFAULT_TABLE = "storage";
-
-    private static final String KEY_ID = "key";
-    private static final String KEY_VALUE = "value";
-    private static final String KEY_CREATED = "created";
-    private static final String KEY_UPDATED = "updated";
-    private static final String KEY_EXPIRES = "expires";
-    private static final String KEY_TAGS = "tags";
-    private static final String KEY_METADATA = "metadata";
-
-    /** 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, 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) {
-        // 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 + " TEXT NOT NULL,"
-                + KEY_CREATED + " INTEGER NOT NULL,"
-                + KEY_UPDATED + " INTEGER NOT NULL,"
-                + KEY_EXPIRES + " INTEGER,"
-                + KEY_TAGS + " TEXT,"
-                + KEY_METADATA + " TEXT" + ")";
-        db.execSQL(createTable);
-        ensuredTables.add(safeTable);
-    }
-
-    /**
-     * 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;
-        }
-        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, 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));
-        }
-        // 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());
-        }
-        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;
-        }
-    }
-
-    /**
-     * 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(safeTable, new String[]{KEY_VALUE}, KEY_ID + "=?",
-                    new String[]{key}, null, null, null, null);
-            if (cursor != null && cursor.moveToFirst()) {
-                String stored = cursor.getString(0);
-                if (stored == null) {
-                    return null;
-                }
-                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 null;
-        } finally {
-            if (cursor != null) {
-                cursor.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 synchronized boolean clear(String table, String prefix) {
-        String safeTable = sanitizeTable(table);
-        SQLiteDatabase db = getWritableDatabase();
-        ensureTable(db, safeTable);
-        int result;
-        if (prefix != null) {
-            result = db.delete(safeTable, KEY_ID + " LIKE ?", new String[]{prefix + "%"});
-        } else {
-            result = db.delete(safeTable, null, null);
-        }
-        return result >= 0;
-    }
-
-    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 {
-            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));
-                } while (cursor.moveToNext());
-            }
-            return keys;
-        } finally {
-            if (cursor != null) {
-                cursor.close();
-            }
-        }
-    }
-
-    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(safeTable, new String[]{KEY_ID}, KEY_ID + "=?",
-                    new String[]{key}, null, null, null, null);
-            return cursor != null && cursor.getCount() > 0;
-        } finally {
-            if (cursor != null) {
-                cursor.close();
-            }
-        }
-    }
-
-    /**
-     * 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.query(safeTable, new String[]{KEY_ID},
-                    null, null, null, null, null);
-            if (cursor != null && cursor.moveToFirst()) {
-                do {
-                    Map<String, Object> row = new HashMap<>();
-                    row.put("key", cursor.getString(0));
-                    rows.add(row);
-                } while (cursor.moveToNext());
-            }
-            return rows;
-        } finally {
-            if (cursor != null) {
-                cursor.close();
-            }
-        }
-    }
-
-    /**
-     * 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.
-     */
-    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();
-            }
-        }
-    }
-
-    /**
-     * 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;
-        }
-    }
-}