strata-storage 1.0.0

package/ios/Plugin/SQLiteStorage.swift

@@ -0,0 +1,167 @@
+import Foundation
+import SQLite3
+
+@objc public class SQLiteStorage: NSObject {
+    private var db: OpaquePointer?
+    private let dbName: String
+    private let tableName = "strata_storage"
+    
+    @objc public init(dbName: String = "strata.db") {
+        self.dbName = dbName
+        super.init()
+        openDatabase()
+        createTable()
+    }
+    
+    deinit {
+        closeDatabase()
+    }
+    
+    private func openDatabase() {
+        let fileURL = try! FileManager.default
+            .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
+            .appendingPathComponent(dbName)
+        
+        if sqlite3_open(fileURL.path, &db) != SQLITE_OK {
+            print("Unable to open database")
+        }
+    }
+    
+    private func closeDatabase() {
+        sqlite3_close(db)
+    }
+    
+    private func createTable() {
+        let createTableString = """
+            CREATE TABLE IF NOT EXISTS \(tableName) (
+                key TEXT PRIMARY KEY NOT NULL,
+                value BLOB NOT NULL,
+                created INTEGER NOT NULL,
+                updated INTEGER NOT NULL,
+                expires INTEGER,
+                tags TEXT,
+                metadata TEXT
+            );
+        """
+        
+        var createTableStatement: OpaquePointer?
+        if sqlite3_prepare_v2(db, createTableString, -1, &createTableStatement, nil) == SQLITE_OK {
+            if sqlite3_step(createTableStatement) == SQLITE_DONE {
+                print("Storage table created.")
+            }
+        }
+        sqlite3_finalize(createTableStatement)
+    }
+    
+    @objc public func set(key: String, value: Data, expires: Int64? = nil, tags: [String]? = nil, metadata: [String: Any]? = nil) -> Bool {
+        let now = Int64(Date().timeIntervalSince1970 * 1000)
+        let tagsJson = tags != nil ? try? JSONSerialization.data(withJSONObject: tags!, options: []) : nil
+        let metadataJson = metadata != nil ? try? JSONSerialization.data(withJSONObject: metadata!, options: []) : nil
+        
+        let insertSQL = """
+            INSERT OR REPLACE INTO \(tableName) 
+            (key, value, created, updated, expires, tags, metadata) 
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        """
+        
+        var statement: OpaquePointer?
+        let result = sqlite3_prepare_v2(db, insertSQL, -1, &statement, nil) == SQLITE_OK &&
+            sqlite3_bind_text(statement, 1, key, -1, nil) == SQLITE_OK &&
+            sqlite3_bind_blob(statement, 2, (value as NSData).bytes, Int32(value.count), nil) == SQLITE_OK &&
+            sqlite3_bind_int64(statement, 3, now) == SQLITE_OK &&
+            sqlite3_bind_int64(statement, 4, now) == SQLITE_OK &&
+            (expires != nil ? sqlite3_bind_int64(statement, 5, expires!) : sqlite3_bind_null(statement, 5)) == SQLITE_OK &&
+            (tagsJson != nil ? sqlite3_bind_blob(statement, 6, (tagsJson! as NSData).bytes, Int32(tagsJson!.count), nil) : sqlite3_bind_null(statement, 6)) == SQLITE_OK &&
+            (metadataJson != nil ? sqlite3_bind_blob(statement, 7, (metadataJson! as NSData).bytes, Int32(metadataJson!.count), nil) : sqlite3_bind_null(statement, 7)) == SQLITE_OK &&
+            sqlite3_step(statement) == SQLITE_DONE
+        
+        sqlite3_finalize(statement)
+        return result
+    }
+    
+    @objc public func get(key: String) -> [String: Any]? {
+        let querySQL = "SELECT * FROM \(tableName) WHERE key = ? LIMIT 1"
+        var statement: OpaquePointer?
+        
+        guard sqlite3_prepare_v2(db, querySQL, -1, &statement, nil) == SQLITE_OK,
+              sqlite3_bind_text(statement, 1, key, -1, nil) == SQLITE_OK else {
+            sqlite3_finalize(statement)
+            return nil
+        }
+        
+        var result: [String: Any]?
+        if sqlite3_step(statement) == SQLITE_ROW {
+            let valueData = Data(bytes: sqlite3_column_blob(statement, 1), count: Int(sqlite3_column_bytes(statement, 1)))
+            let created = sqlite3_column_int64(statement, 2)
+            let updated = sqlite3_column_int64(statement, 3)
+            
+            result = [
+                "key": key,
+                "value": valueData,
+                "created": created,
+                "updated": updated
+            ]
+            
+            if sqlite3_column_type(statement, 4) != SQLITE_NULL {
+                result!["expires"] = sqlite3_column_int64(statement, 4)
+            }
+            
+            if sqlite3_column_type(statement, 5) != SQLITE_NULL {
+                let tagsData = Data(bytes: sqlite3_column_blob(statement, 5), count: Int(sqlite3_column_bytes(statement, 5)))
+                if let tags = try? JSONSerialization.jsonObject(with: tagsData, options: []) {
+                    result!["tags"] = tags
+                }
+            }
+            
+            if sqlite3_column_type(statement, 6) != SQLITE_NULL {
+                let metadataData = Data(bytes: sqlite3_column_blob(statement, 6), count: Int(sqlite3_column_bytes(statement, 6)))
+                if let metadata = try? JSONSerialization.jsonObject(with: metadataData, options: []) {
+                    result!["metadata"] = metadata
+                }
+            }
+        }
+        
+        sqlite3_finalize(statement)
+        return result
+    }
+    
+    @objc public func remove(key: String) -> Bool {
+        let deleteSQL = "DELETE FROM \(tableName) WHERE key = ?"
+        var statement: OpaquePointer?
+        
+        let result = sqlite3_prepare_v2(db, deleteSQL, -1, &statement, nil) == SQLITE_OK &&
+            sqlite3_bind_text(statement, 1, key, -1, nil) == SQLITE_OK &&
+            sqlite3_step(statement) == SQLITE_DONE
+        
+        sqlite3_finalize(statement)
+        return result
+    }
+    
+    @objc public func clear() -> Bool {
+        let deleteSQL = "DELETE FROM \(tableName)"
+        var statement: OpaquePointer?
+        
+        let result = sqlite3_prepare_v2(db, deleteSQL, -1, &statement, nil) == SQLITE_OK &&
+            sqlite3_step(statement) == SQLITE_DONE
+        
+        sqlite3_finalize(statement)
+        return result
+    }
+    
+    @objc public func keys() -> [String] {
+        let querySQL = "SELECT key FROM \(tableName)"
+        var statement: OpaquePointer?
+        var keys: [String] = []
+        
+        if sqlite3_prepare_v2(db, querySQL, -1, &statement, nil) == SQLITE_OK {
+            while sqlite3_step(statement) == SQLITE_ROW {
+                if let key = sqlite3_column_text(statement, 0) {
+                    keys.append(String(cString: key))
+                }
+            }
+        }
+        
+        sqlite3_finalize(statement)
+        return keys
+    }
+}

package/ios/Plugin/StrataStoragePlugin.swift

@@ -0,0 +1,204 @@
+import Foundation
+import Capacitor
+
+/**
+ * Main Capacitor plugin for Strata Storage
+ * Coordinates between different storage types on iOS
+ */
+@objc(StrataStoragePlugin)
+public class StrataStoragePlugin: CAPPlugin {
+    private let userDefaultsStorage = UserDefaultsStorage()
+    private let keychainStorage = KeychainStorage()
+    private let sqliteStorage = SQLiteStorage()
+    
+    /**
+     * Check if storage is available
+     */
+    @objc func isAvailable(_ call: CAPPluginCall) {
+        call.resolve([
+            "available": true,
+            "platform": "ios",
+            "adapters": [
+                "preferences": true,
+                "secure": true,
+                "sqlite": true,
+                "filesystem": true
+            ]
+        ])
+    }
+    
+    /**
+     * Get value from storage
+     */
+    @objc func get(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else {
+            call.reject("Key is required")
+            return
+        }
+        
+        let storage = call.getString("storage") ?? "preferences"
+        
+        do {
+            let value: Any?
+            
+            switch storage {
+            case "secure":
+                value = try keychainStorage.get(key: key)
+            case "sqlite":
+                value = try sqliteStorage.get(key: key)
+            case "preferences":
+                fallthrough
+            default:
+                value = userDefaultsStorage.get(key: key)
+            }
+            
+            call.resolve([
+                "value": value ?? NSNull()
+            ])
+        } catch {
+            call.reject("Failed to get value", error.localizedDescription)
+        }
+    }
+    
+    /**
+     * Set value in storage
+     */
+    @objc func set(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else {
+            call.reject("Key is required")
+            return
+        }
+        
+        let value = call.getValue("value") ?? NSNull()
+        let storage = call.getString("storage") ?? "preferences"
+        
+        do {
+            switch storage {
+            case "secure":
+                try keychainStorage.set(key: key, value: value)
+            case "sqlite":
+                try sqliteStorage.set(key: key, value: value)
+            case "preferences":
+                fallthrough
+            default:
+                userDefaultsStorage.set(key: key, value: value)
+            }
+            
+            call.resolve()
+        } catch {
+            call.reject("Failed to set value", error.localizedDescription)
+        }
+    }
+    
+    /**
+     * Remove value from storage
+     */
+    @objc func remove(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else {
+            call.reject("Key is required")
+            return
+        }
+        
+        let storage = call.getString("storage") ?? "preferences"
+        
+        do {
+            switch storage {
+            case "secure":
+                try keychainStorage.remove(key: key)
+            case "sqlite":
+                try sqliteStorage.remove(key: key)
+            case "preferences":
+                fallthrough
+            default:
+                userDefaultsStorage.remove(key: key)
+            }
+            
+            call.resolve()
+        } catch {
+            call.reject("Failed to remove value", error.localizedDescription)
+        }
+    }
+    
+    /**
+     * Clear storage
+     */
+    @objc func clear(_ call: CAPPluginCall) {
+        let storage = call.getString("storage") ?? "preferences"
+        let prefix = call.getString("prefix")
+        
+        do {
+            switch storage {
+            case "secure":
+                try keychainStorage.clear(prefix: prefix)
+            case "sqlite":
+                try sqliteStorage.clear(prefix: prefix)
+            case "preferences":
+                fallthrough
+            default:
+                userDefaultsStorage.clear(prefix: prefix)
+            }
+            
+            call.resolve()
+        } catch {
+            call.reject("Failed to clear storage", error.localizedDescription)
+        }
+    }
+    
+    /**
+     * Get all keys from storage
+     */
+    @objc func keys(_ call: CAPPluginCall) {
+        let storage = call.getString("storage") ?? "preferences"
+        let pattern = call.getString("pattern")
+        
+        do {
+            let keys: [String]
+            
+            switch storage {
+            case "secure":
+                keys = try keychainStorage.keys(pattern: pattern)
+            case "sqlite":
+                keys = try sqliteStorage.keys(pattern: pattern)
+            case "preferences":
+                fallthrough
+            default:
+                keys = userDefaultsStorage.keys(pattern: pattern)
+            }
+            
+            call.resolve([
+                "keys": keys
+            ])
+        } catch {
+            call.reject("Failed to get keys", error.localizedDescription)
+        }
+    }
+    
+    /**
+     * Get storage size information
+     */
+    @objc func size(_ call: CAPPluginCall) {
+        let storage = call.getString("storage") ?? "preferences"
+        
+        do {
+            let sizeInfo: (total: Int, count: Int)
+            
+            switch storage {
+            case "secure":
+                sizeInfo = try keychainStorage.size()
+            case "sqlite":
+                sizeInfo = try sqliteStorage.size()
+            case "preferences":
+                fallthrough
+            default:
+                sizeInfo = userDefaultsStorage.size()
+            }
+            
+            call.resolve([
+                "total": sizeInfo.total,
+                "count": sizeInfo.count
+            ])
+        } catch {
+            call.reject("Failed to get size", error.localizedDescription)
+        }
+    }
+}

package/ios/Plugin/UserDefaultsStorage.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+@objc public class UserDefaultsStorage: NSObject {
+    private let suiteName: String?
+    private var userDefaults: UserDefaults
+    
+    @objc public init(suiteName: String? = nil) {
+        self.suiteName = suiteName
+        self.userDefaults = suiteName != nil ? UserDefaults(suiteName: suiteName)! : UserDefaults.standard
+        super.init()
+    }
+    
+    @objc public func set(key: String, value: Any) -> Bool {
+        userDefaults.set(value, forKey: key)
+        return userDefaults.synchronize()
+    }
+    
+    @objc public func get(key: String) -> Any? {
+        return userDefaults.object(forKey: key)
+    }
+    
+    @objc public func remove(key: String) -> Bool {
+        userDefaults.removeObject(forKey: key)
+        return userDefaults.synchronize()
+    }
+    
+    @objc public func clear() -> Bool {
+        if let suiteName = suiteName {
+            UserDefaults(suiteName: suiteName)?.removePersistentDomain(forName: suiteName)
+        } else {
+            let domain = Bundle.main.bundleIdentifier!
+            userDefaults.removePersistentDomain(forName: domain)
+        }
+        return userDefaults.synchronize()
+    }
+    
+    @objc public func keys() -> [String] {
+        return Array(userDefaults.dictionaryRepresentation().keys)
+    }
+    
+    @objc public func has(key: String) -> Bool {
+        return userDefaults.object(forKey: key) != nil
+    }
+}

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "strata-storage",
+  "version": "1.0.0",
+  "description": "Zero-dependency universal storage plugin providing a unified API for all storage operations across web, Android, and iOS platforms",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "ios/",
+    "android/",
+    "scripts/"
+  ],
+  "bin": {
+    "strata-storage": "./scripts/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/integrations/react/index.esm.js",
+      "require": "./dist/integrations/react/index.js",
+      "types": "./dist/integrations/react/index.d.ts"
+    },
+    "./vue": {
+      "import": "./dist/integrations/vue/index.esm.js",
+      "require": "./dist/integrations/vue/index.js",
+      "types": "./dist/integrations/vue/index.d.ts"
+    },
+    "./angular": {
+      "import": "./dist/integrations/angular/index.esm.js",
+      "require": "./dist/integrations/angular/index.js",
+      "types": "./dist/integrations/angular/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "yarn clean && yarn build:web && yarn build:types",
+    "build:web": "node scripts/build.js",
+    "build:types": "tsc --emitDeclarationOnly",
+    "clean": "rm -rf dist/",
+    "lint": "eslint 'src/**/*.{ts,tsx}' --ignore-pattern 'src/integrations/**/*' --fix",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "prepublishOnly": "yarn build && yarn lint && yarn typecheck",
+    "postinstall": "node scripts/postinstall.js || true"
+  },
+  "keywords": [
+    "storage",
+    "capacitor",
+    "ionic",
+    "react",
+    "vue",
+    "angular",
+    "localStorage",
+    "indexedDB",
+    "sqlite",
+    "keychain",
+    "preferences",
+    "zero-dependencies",
+    "cross-platform",
+    "web",
+    "ios",
+    "android"
+  ],
+  "author": "Ahsan Mahmood",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aoneahsan/strata-storage.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aoneahsan/strata-storage/issues"
+  },
+  "homepage": "https://github.com/aoneahsan/strata-storage#readme",
+  "dependencies": {},
+  "peerDependencies": {
+    "@angular/core": ">=12.0.0",
+    "@capacitor/core": "^5.0.0 || ^6.0.0",
+    "react": ">=16.8.0",
+    "vue": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@capacitor/core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.32.0",
+    "@types/node": "^24.1.0",
+    "@types/react": "^19.1.9",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.32.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.3",
+    "prettier": "^3.6.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.38.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}

package/scripts/build.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const rootDir = path.join(__dirname, '..');
+const srcDir = path.join(rootDir, 'src');
+const distDir = path.join(rootDir, 'dist');
+
+console.log('🔨 Building Strata Storage...');
+
+// Ensure dist directory exists
+if (!fs.existsSync(distDir)) {
+  fs.mkdirSync(distDir, { recursive: true });
+}
+
+// Compile TypeScript
+console.log('📦 Compiling TypeScript...');
+try {
+  execSync('npx tsc', { stdio: 'inherit', cwd: rootDir });
+} catch (error) {
+  console.error('❌ TypeScript compilation failed');
+  process.exit(1);
+}
+
+// Copy package.json fields for publishing
+console.log('📋 Preparing package metadata...');
+const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+const distPackageJson = {
+  name: packageJson.name,
+  version: packageJson.version,
+  description: packageJson.description,
+  main: 'index.js',
+  module: 'index.esm.js',
+  types: 'index.d.ts',
+  author: packageJson.author,
+  license: packageJson.license,
+  repository: packageJson.repository,
+  keywords: packageJson.keywords,
+  peerDependencies: packageJson.peerDependencies,
+  peerDependenciesMeta: packageJson.peerDependenciesMeta,
+  capacitor: packageJson.capacitor,
+};
+
+fs.writeFileSync(
+  path.join(distDir, 'package.json'),
+  JSON.stringify(distPackageJson, null, 2)
+);
+
+console.log('✅ Build completed successfully!');
+console.log(`📂 Output: ${distDir}`);

package/scripts/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * Strata Storage CLI
+ * Main entry point for npx commands
+ */
+
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Get command from arguments
+const command = process.argv[2];
+
+// Available commands
+const commands = {
+  configure: 'configure.js',
+  init: 'configure.js',
+  setup: 'configure.js'
+};
+
+// Show help if no command
+if (!command || command === '--help' || command === '-h') {
+  console.log(`
+🗄️  Strata Storage CLI
+
+Usage: npx strata-storage <command>
+
+Commands:
+  configure    Interactive configuration wizard
+  init         Alias for configure
+  setup        Alias for configure
+  --help       Show this help message
+
+Examples:
+  npx strata-storage configure
+  npx strata-storage init
+
+Documentation: https://github.com/aoneahsan/strata-storage
+`);
+  process.exit(0);
+}
+
+// Check if command exists
+const scriptFile = commands[command];
+if (!scriptFile) {
+  console.error(`Unknown command: ${command}`);
+  console.log('Run "npx strata-storage --help" for available commands.');
+  process.exit(1);
+}
+
+// Run the command
+const scriptPath = path.join(__dirname, scriptFile);
+const child = spawn('node', [scriptPath, ...process.argv.slice(3)], {
+  stdio: 'inherit',
+  shell: true
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});