strata-storage 1.0.0

package/Readme.md

@@ -0,0 +1,113 @@
+# Strata Storage
+
+## 📚 Documentation
+
+- **[Full Documentation](https://strata-storage.dev)** *(coming soon)*
+- **[API Reference](https://strata-storage.dev/api)**
+- **[Platform Guides](https://strata-storage.dev/platforms)**
+- **[Examples](https://strata-storage.dev/examples)**
+- **[GitHub](https://github.com/aoneahsan/strata-storage)**
+
+---
+
+**One API. Every Storage. Everywhere.**
+
+Zero-dependency universal storage plugin providing a unified API for all storage operations across web, Android, and iOS platforms.
+
+## 🚀 Quick Start
+
+```bash
+npm install strata-storage
+```
+
+```typescript
+import { Strata } from 'strata-storage';
+
+const storage = new Strata();
+await storage.initialize();
+
+// Works everywhere - web, iOS, Android
+await storage.set('user', { name: 'John', age: 30 });
+const user = await storage.get('user');
+```
+
+## ✨ Features
+
+### Core Features
+- ✅ **Zero Dependencies** - No external packages, pure implementation
+- ✅ **Universal API** - Single interface for all storage types
+- ✅ **Cross-Platform** - Web, iOS, Android support
+- ✅ **TypeScript** - Full type safety and IntelliSense
+- ✅ **Auto Fallback** - Intelligent storage selection
+
+### Storage Adapters
+- ✅ **Memory** - Fast in-memory storage
+- ✅ **LocalStorage** - Persistent browser storage
+- ✅ **SessionStorage** - Session-based browser storage
+- ✅ **IndexedDB** - Large-scale browser database
+- ✅ **Cookies** - HTTP cookie storage
+- ✅ **Cache API** - Service worker cache storage
+- ✅ **Capacitor Preferences** - Native mobile preferences
+- ✅ **SQLite** - Mobile SQL database
+- ✅ **Secure Storage** - Keychain (iOS) / Encrypted SharedPreferences (Android)
+- ✅ **Filesystem** - File-based storage
+
+### Advanced Features
+- ✅ **Encryption** - AES-GCM encryption with Web Crypto API
+- ✅ **Compression** - LZ-string compression algorithm
+- ✅ **Cross-Tab Sync** - Real-time synchronization across tabs
+- ✅ **Query Engine** - MongoDB-like queries for filtering data
+- ✅ **TTL Support** - Automatic expiration with sliding TTL
+- ✅ **Migration System** - Version-based data migrations
+- 🚧 **Framework Integrations** - React, Vue, Angular (coming soon)
+
+## 📖 Basic Usage
+
+```typescript
+// Initialize with configuration
+const storage = new Strata({
+  defaultStorages: ['indexedDB', 'localStorage', 'memory'],
+  encryption: { enabled: true },
+  compression: { enabled: true },
+  ttl: { defaultTTL: 3600000 } // 1 hour
+});
+
+await storage.initialize();
+
+// Store with options
+await storage.set('key', value, {
+  ttl: 3600000,        // Expire in 1 hour
+  encrypt: true,       // Encrypt this value
+  compress: true,      // Compress if beneficial
+  tags: ['user-data'] // Tag for grouping
+});
+
+// Query data
+const results = await storage.query({
+  tags: { $in: ['user-data'] },
+  'value.age': { $gte: 18 }
+});
+
+// Subscribe to changes
+storage.subscribe((change) => {
+  console.log(`${change.key} changed from ${change.oldValue} to ${change.newValue}`);
+});
+```
+
+## 🏗 Project Status
+
+Currently in active development. Phase 1-5 completed:
+- ✅ Project setup and core architecture
+- ✅ Memory and web storage adapters
+- ✅ Capacitor plugin structure
+- ✅ Advanced features (encryption, compression, sync, query, TTL)
+- 🚧 Native implementations (iOS/Android)
+- 🚧 Testing and documentation
+
+## 📄 License
+
+MIT
+
+---
+
+Created by Ahsan Mahmood

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

@@ -0,0 +1,65 @@
+package com.strata.storage;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Build;
+import androidx.security.crypto.EncryptedSharedPreferences;
+import androidx.security.crypto.MasterKey;
+import java.util.Set;
+import java.util.Map;
+
+public class EncryptedStorage {
+    private SharedPreferences encryptedPrefs;
+    private SharedPreferences.Editor editor;
+    
+    public EncryptedStorage(Context context, String name) throws Exception {
+        String fileName = name != null ? name : "StrataSecureStorage";
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            MasterKey masterKey = new MasterKey.Builder(context)
+                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+                .build();
+                
+            encryptedPrefs = EncryptedSharedPreferences.create(
+                context,
+                fileName,
+                masterKey,
+                EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+                EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+            );
+            
+            editor = encryptedPrefs.edit();
+        } else {
+            // Fallback to regular SharedPreferences for older devices
+            encryptedPrefs = context.getSharedPreferences(fileName, Context.MODE_PRIVATE);
+            editor = encryptedPrefs.edit();
+        }
+    }
+    
+    public boolean set(String key, String value) {
+        editor.putString(key, value);
+        return editor.commit();
+    }
+    
+    public String get(String key) {
+        return encryptedPrefs.getString(key, null);
+    }
+    
+    public boolean remove(String key) {
+        editor.remove(key);
+        return editor.commit();
+    }
+    
+    public boolean clear() {
+        editor.clear();
+        return editor.commit();
+    }
+    
+    public Set<String> keys() {
+        return encryptedPrefs.getAll().keySet();
+    }
+    
+    public boolean has(String key) {
+        return encryptedPrefs.contains(key);
+    }
+}

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

@@ -0,0 +1,147 @@
+package com.strata.storage;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.content.ContentValues;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SQLiteStorage extends SQLiteOpenHelper {
+    private static final int DATABASE_VERSION = 1;
+    private static final String TABLE_NAME = "strata_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";
+    
+    public SQLiteStorage(Context context, String dbName) {
+        super(context, dbName != null ? dbName : "strata.db", null, DATABASE_VERSION);
+    }
+    
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + "("
+                + KEY_ID + " TEXT PRIMARY KEY,"
+                + KEY_VALUE + " BLOB 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);
+    }
+    
+    public boolean set(String key, byte[] value, Long expires, String tags, String metadata) {
+        SQLiteDatabase db = this.getWritableDatabase();
+        ContentValues values = new ContentValues();
+        
+        long now = System.currentTimeMillis();
+        values.put(KEY_ID, key);
+        values.put(KEY_VALUE, value);
+        values.put(KEY_CREATED, now);
+        values.put(KEY_UPDATED, now);
+        
+        if (expires != null) {
+            values.put(KEY_EXPIRES, expires);
+        }
+        if (tags != null) {
+            values.put(KEY_TAGS, tags);
+        }
+        if (metadata != null) {
+            values.put(KEY_METADATA, metadata);
+        }
+        
+        long result = db.insertWithOnConflict(TABLE_NAME, null, values, SQLiteDatabase.CONFLICT_REPLACE);
+        db.close();
+        return result != -1;
+    }
+    
+    public Map<String, Object> get(String key) {
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.query(TABLE_NAME, null, 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));
+            }
+            
+            int metadataIndex = cursor.getColumnIndex(KEY_METADATA);
+            if (!cursor.isNull(metadataIndex)) {
+                result.put("metadata", cursor.getString(metadataIndex));
+            }
+            
+            cursor.close();
+        }
+        db.close();
+        return result;
+    }
+    
+    public boolean remove(String key) {
+        SQLiteDatabase db = this.getWritableDatabase();
+        int result = db.delete(TABLE_NAME, KEY_ID + " = ?", new String[]{key});
+        db.close();
+        return result > 0;
+    }
+    
+    public boolean clear() {
+        SQLiteDatabase db = this.getWritableDatabase();
+        db.delete(TABLE_NAME, null, null);
+        db.close();
+        return true;
+    }
+    
+    public List<String> keys() {
+        List<String> keys = new ArrayList<>();
+        String selectQuery = "SELECT " + KEY_ID + " FROM " + TABLE_NAME;
+        
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.rawQuery(selectQuery, null);
+        
+        if (cursor.moveToFirst()) {
+            do {
+                keys.add(cursor.getString(0));
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        db.close();
+        return keys;
+    }
+    
+    public boolean has(String key) {
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.query(TABLE_NAME, new String[]{KEY_ID}, KEY_ID + "=?",
+                new String[]{key}, null, null, null, null);
+        boolean exists = cursor.getCount() > 0;
+        cursor.close();
+        db.close();
+        return exists;
+    }
+}

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

@@ -0,0 +1,74 @@
+package com.strata.storage;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import java.util.Map;
+import java.util.Set;
+import java.util.HashSet;
+import org.json.JSONObject;
+import org.json.JSONArray;
+
+public class SharedPreferencesStorage {
+    private final SharedPreferences prefs;
+    private final SharedPreferences.Editor editor;
+    
+    public SharedPreferencesStorage(Context context, String name) {
+        this.prefs = context.getSharedPreferences(name != null ? name : "StrataStorage", Context.MODE_PRIVATE);
+        this.editor = prefs.edit();
+    }
+    
+    public boolean set(String key, Object value) {
+        try {
+            if (value instanceof String) {
+                editor.putString(key, (String) value);
+            } else if (value instanceof Integer) {
+                editor.putInt(key, (Integer) value);
+            } else if (value instanceof Long) {
+                editor.putLong(key, (Long) value);
+            } else if (value instanceof Float) {
+                editor.putFloat(key, (Float) value);
+            } else if (value instanceof Boolean) {
+                editor.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Set) {
+                editor.putStringSet(key, (Set<String>) value);
+            } else {
+                // Convert complex objects to JSON
+                String json = value instanceof JSONObject ? 
+                    ((JSONObject) value).toString() : 
+                    new JSONObject(value).toString();
+                editor.putString(key, json);
+            }
+            return editor.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+    
+    public Object get(String key) {
+        Map<String, ?> all = prefs.getAll();
+        return all.get(key);
+    }
+    
+    public boolean remove(String key) {
+        editor.remove(key);
+        return editor.commit();
+    }
+    
+    public boolean clear() {
+        editor.clear();
+        return editor.commit();
+    }
+    
+    public Set<String> keys() {
+        return prefs.getAll().keySet();
+    }
+    
+    public boolean has(String key) {
+        return prefs.contains(key);
+    }
+    
+    public Map<String, ?> getAll() {
+        return prefs.getAll();
+    }
+}

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

@@ -0,0 +1,256 @@
+package com.stratastorage;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import org.json.JSONArray;
+import org.json.JSONException;
+import java.util.List;
+
+/**
+ * Main Capacitor plugin for Strata Storage
+ * Coordinates between different storage types on Android
+ */
+@CapacitorPlugin(name = "StrataStorage")
+public class StrataStoragePlugin extends Plugin {
+    private SharedPreferencesStorage sharedPrefsStorage;
+    private EncryptedStorage encryptedStorage;
+    private SQLiteStorage sqliteStorage;
+
+    @Override
+    public void load() {
+        sharedPrefsStorage = new SharedPreferencesStorage(getContext());
+        encryptedStorage = new EncryptedStorage(getContext());
+        sqliteStorage = new SQLiteStorage(getContext());
+    }
+
+    /**
+     * Check if storage is available
+     */
+    @PluginMethod
+    public void isAvailable(PluginCall call) {
+        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);
+        
+        call.resolve(result);
+    }
+
+    /**
+     * Get value from storage
+     */
+    @PluginMethod
+    public void get(PluginCall call) {
+        String key = call.getString("key");
+        if (key == null) {
+            call.reject("Key is required");
+            return;
+        }
+
+        String storage = call.getString("storage", "preferences");
+        
+        try {
+            Object value = null;
+            
+            switch (storage) {
+                case "secure":
+                    value = encryptedStorage.get(key);
+                    break;
+                case "sqlite":
+                    value = sqliteStorage.get(key);
+                    break;
+                case "preferences":
+                default:
+                    value = sharedPrefsStorage.get(key);
+                    break;
+            }
+            
+            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
+     */
+    @PluginMethod
+    public void set(PluginCall call) {
+        String key = call.getString("key");
+        if (key == null) {
+            call.reject("Key is required");
+            return;
+        }
+
+        Object value = call.getData().opt("value");
+        String storage = call.getString("storage", "preferences");
+        
+        try {
+            switch (storage) {
+                case "secure":
+                    encryptedStorage.set(key, value);
+                    break;
+                case "sqlite":
+                    sqliteStorage.set(key, value);
+                    break;
+                case "preferences":
+                default:
+                    sharedPrefsStorage.set(key, value);
+                    break;
+            }
+            
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to set value", e);
+        }
+    }
+
+    /**
+     * Remove value from storage
+     */
+    @PluginMethod
+    public void remove(PluginCall call) {
+        String key = call.getString("key");
+        if (key == null) {
+            call.reject("Key is required");
+            return;
+        }
+
+        String storage = call.getString("storage", "preferences");
+        
+        try {
+            switch (storage) {
+                case "secure":
+                    encryptedStorage.remove(key);
+                    break;
+                case "sqlite":
+                    sqliteStorage.remove(key);
+                    break;
+                case "preferences":
+                default:
+                    sharedPrefsStorage.remove(key);
+                    break;
+            }
+            
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to remove value", e);
+        }
+    }
+
+    /**
+     * Clear storage
+     */
+    @PluginMethod
+    public void clear(PluginCall call) {
+        String storage = call.getString("storage", "preferences");
+        String prefix = call.getString("prefix");
+        
+        try {
+            switch (storage) {
+                case "secure":
+                    encryptedStorage.clear(prefix);
+                    break;
+                case "sqlite":
+                    sqliteStorage.clear(prefix);
+                    break;
+                case "preferences":
+                default:
+                    sharedPrefsStorage.clear(prefix);
+                    break;
+            }
+            
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to clear storage", e);
+        }
+    }
+
+    /**
+     * Get all keys from storage
+     */
+    @PluginMethod
+    public void keys(PluginCall call) {
+        String storage = call.getString("storage", "preferences");
+        String pattern = call.getString("pattern");
+        
+        try {
+            List<String> keys = null;
+            
+            switch (storage) {
+                case "secure":
+                    keys = encryptedStorage.keys(pattern);
+                    break;
+                case "sqlite":
+                    keys = sqliteStorage.keys(pattern);
+                    break;
+                case "preferences":
+                default:
+                    keys = sharedPrefsStorage.keys(pattern);
+                    break;
+            }
+            
+            JSObject result = new JSObject();
+            result.put("keys", new JSONArray(keys));
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Failed to get keys", e);
+        }
+    }
+
+    /**
+     * Get storage size information
+     */
+    @PluginMethod
+    public void size(PluginCall call) {
+        String storage = call.getString("storage", "preferences");
+        
+        try {
+            SizeInfo sizeInfo = null;
+            
+            switch (storage) {
+                case "secure":
+                    sizeInfo = encryptedStorage.size();
+                    break;
+                case "sqlite":
+                    sizeInfo = sqliteStorage.size();
+                    break;
+                case "preferences":
+                default:
+                    sizeInfo = sharedPrefsStorage.size();
+                    break;
+            }
+            
+            JSObject result = new JSObject();
+            result.put("total", sizeInfo.total);
+            result.put("count", sizeInfo.count);
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Failed to get size", e);
+        }
+    }
+    
+    /**
+     * Size information class
+     */
+    static class SizeInfo {
+        public final long total;
+        public final int count;
+        
+        public SizeInfo(long total, int count) {
+            this.total = total;
+            this.count = count;
+        }
+    }
+}

package/dist/adapters/capacitor/FilesystemAdapter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Filesystem Adapter - Native file system storage
+ * Direct file access on iOS and Android
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import type { StorageType, StorageCapabilities, StorageValue, ClearOptions, SizeInfo } from '@/types';
+/**
+ * Native filesystem adapter using Capacitor plugin
+ */
+export declare class FilesystemAdapter extends BaseAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    /**
+     * Check if filesystem is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Initialize the adapter
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get a value from filesystem
+     */
+    get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    /**
+     * Set a value in filesystem
+     */
+    set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from filesystem
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear filesystem storage
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Get storage size
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+}
+//# sourceMappingURL=FilesystemAdapter.d.ts.map

package/dist/adapters/capacitor/FilesystemAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilesystemAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/capacitor/FilesystemAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,QAAQ,EACT,MAAM,SAAS,CAAC;AAKjB;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAgB;IAC1C,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAUxC;IAEF;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAWrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAwBpE;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB1E;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBxC;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlD;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAwBxD;;OAEG;IACG,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;CAYlD"}