strata-storage 1.5.0 → 1.6.0

package/dist/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/dist/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/dist/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/dist/package.json

@@ -1,10 +1,16 @@
 {
   "name": "strata-storage",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Zero-dependency universal storage plugin providing a unified API for all storage operations across web, Android, and iOS platforms",
-  "main": "index.js",
-  "module": "index.esm.js",
-  "types": "index.d.ts",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
   "author": "Ahsan Mahmood",
   "license": "MIT",
   "repository": {
@@ -56,5 +62,9 @@
     "android": {
       "src": "android"
     }
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

package/dist/plugin/index.js

@@ -20,8 +20,8 @@ if (typeof window !== 'undefined') {
     const cap = window.Capacitor;
     if (cap && cap.registerPlugin) {
         StrataStorage = cap.registerPlugin('StrataStorage', {
-            web: () => import('./web').then((m) => new m.StrataStorageWeb()),
+            web: () => import("./web.js").then((m) => new m.StrataStorageWeb()),
         });
     }
 }
-export * from './definitions';
+export * from "./definitions.js";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "strata-storage",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Zero-dependency universal storage plugin providing a unified API for all storage operations across web, Android, and iOS platforms",
+  "type": "module",
   "main": "dist/index.js",
-  "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist/",
@@ -17,32 +17,14 @@
   },
   "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"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
-    "build": "yarn clean && yarn build:web && yarn build:types",
-    "build:web": "node scripts/build.js",
-    "build:types": "tsc --emitDeclarationOnly",
+    "build": "node scripts/build.js",
     "clean": "rm -rf dist/",
-    "lint": "eslint 'src/**/*.{ts,tsx}' --ignore-pattern 'src/integrations/**/*' --fix",
+    "lint": "eslint 'src/**/*.{ts,tsx}' --fix",
     "typecheck": "tsc --noEmit",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
@@ -99,7 +81,7 @@
     }
   },
   "devDependencies": {
-    "@eslint/js": "^9.32.0",
+    "@eslint/js": "^10.0.0",
     "@types/node": "^24.1.0",
     "@types/react": "^19.1.9",
     "@typescript-eslint/eslint-plugin": "^8.38.0",
@@ -109,7 +91,7 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.3",
     "prettier": "^3.6.2",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.2",
     "typescript-eslint": "^8.38.0",
     "vitest": "^3.2.4"
   },

package/scripts/build.js

@@ -1,39 +1,140 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 const rootDir = path.join(__dirname, '..');
 const srcDir = path.join(rootDir, 'src');
 const distDir = path.join(rootDir, 'dist');
 
-console.log('🔨 Building Strata Storage...');
+console.log('🔨 Building Strata Storage (ESM)...');
 
-// Ensure dist directory exists
-if (!fs.existsSync(distDir)) {
-  fs.mkdirSync(distDir, { recursive: true });
+// Clean dist directory
+console.log('🧹 Cleaning dist directory...');
+if (fs.existsSync(distDir)) {
+  fs.rmSync(distDir, { recursive: true, force: true });
 }
 
-// Compile TypeScript
-console.log('📦 Compiling TypeScript...');
+// Ensure dist directory exists
+fs.mkdirSync(distDir, { recursive: true });
+
+// Compile TypeScript to ESM
+console.log('📦 Building ES Modules...');
 try {
   execSync('npx tsc', { stdio: 'inherit', cwd: rootDir });
 } catch (error) {
-  console.error('❌ TypeScript compilation failed');
+  console.error('❌ Build failed');
   process.exit(1);
 }
 
-// Copy package.json fields for publishing
+// Fix path aliases in all built files
+console.log('🔧 Fixing path aliases...');
+const fixPathAliases = (dir) => {
+  const files = fs.readdirSync(dir);
+  
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    
+    if (stat.isDirectory()) {
+      fixPathAliases(filePath);
+    } else if (file.endsWith('.js')) {
+      let content = fs.readFileSync(filePath, 'utf8');
+      
+      // Calculate depth from dist root
+      const relativeFromDist = path.relative(distDir, path.dirname(filePath));
+      const depth = relativeFromDist ? relativeFromDist.split(path.sep).length : 0;
+      const pathToRoot = depth > 0 ? '../'.repeat(depth) : './';
+      
+      // Fix all @/ imports with proper aliasing
+      content = content
+        .replace(/from\s+["']@\/core\//g, `from "${pathToRoot}core/`)
+        .replace(/from\s+["']@\/adapters\//g, `from "${pathToRoot}adapters/`)
+        .replace(/from\s+["']@\/features\//g, `from "${pathToRoot}features/`)
+        .replace(/from\s+["']@\/utils\//g, `from "${pathToRoot}utils/`)
+        .replace(/from\s+["']@\/plugin\//g, `from "${pathToRoot}plugin/`)
+        .replace(/from\s+["']@\/types\//g, `from "${pathToRoot}types/`)
+        .replace(/from\s+["']@\/utils["']/g, `from "${pathToRoot}utils/index.js"`)
+        .replace(/from\s+["']@\/plugin["']/g, `from "${pathToRoot}plugin/index.js"`)
+        .replace(/import\(["']@\/core\//g, `import("${pathToRoot}core/`)
+        .replace(/import\(["']@\/adapters\//g, `import("${pathToRoot}adapters/`)
+        .replace(/import\(["']@\/features\//g, `import("${pathToRoot}features/`)
+        .replace(/import\(["']@\/utils\//g, `import("${pathToRoot}utils/`)
+        .replace(/import\(["']@\/plugin\//g, `import("${pathToRoot}plugin/`)
+        .replace(/import\(["']@\/types\//g, `import("${pathToRoot}types/`)
+        .replace(/import\(["']@\/utils["']\)/g, `import("${pathToRoot}utils/index.js")`)
+        .replace(/import\(["']@\/plugin["']\)/g, `import("${pathToRoot}plugin/index.js")`);
+      
+      // Also fix any remaining short imports that should point to index.js
+      content = content
+        .replace(/from\s+["']\.\/utils["']/g, `from "./utils/index.js"`)
+        .replace(/from\s+["']\.\/plugin["']/g, `from "./plugin/index.js"`);
+      
+      // Add .js extension to relative imports
+      content = content
+        .replace(/from\s+["'](\.[^"']+)["']/g, (match, path) => {
+          if (!path.endsWith('.js') && !path.endsWith('.json')) {
+            return `from "${path}.js"`;
+          }
+          return match;
+        })
+        .replace(/import\(["'](\.[^"']+)["']\)/g, (match, path) => {
+          if (!path.endsWith('.js') && !path.endsWith('.json')) {
+            return `import("${path}.js")`;
+          }
+          return match;
+        });
+      
+      fs.writeFileSync(filePath, content);
+    }
+  });
+};
+
+fixPathAliases(distDir);
+
+// Copy native directories if they exist
+console.log('📱 Copying native code...');
+const nativeDirs = ['android', 'ios'];
+nativeDirs.forEach(dir => {
+  const srcPath = path.join(rootDir, dir);
+  const destPath = path.join(distDir, dir);
+  if (fs.existsSync(srcPath)) {
+    fs.cpSync(srcPath, destPath, { recursive: true });
+  }
+});
+
+// Copy other files
+console.log('📄 Copying additional files...');
+const filesToCopy = ['README.md', 'LICENSE'];
+filesToCopy.forEach(file => {
+  const srcPath = path.join(rootDir, file);
+  const destPath = path.join(distDir, file);
+  if (fs.existsSync(srcPath)) {
+    fs.copyFileSync(srcPath, destPath);
+  }
+});
+
+// Create package.json for distribution
 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',
+  type: 'module',
+  main: './index.js',
+  types: './index.d.ts',
+  exports: {
+    '.': {
+      types: './index.d.ts',
+      default: './index.js'
+    }
+  },
   author: packageJson.author,
   license: packageJson.license,
   repository: packageJson.repository,
@@ -41,6 +142,10 @@ const distPackageJson = {
   peerDependencies: packageJson.peerDependencies,
   peerDependenciesMeta: packageJson.peerDependenciesMeta,
   capacitor: packageJson.capacitor,
+  sideEffects: false,
+  engines: {
+    node: '>=18.0.0'
+  }
 };
 
 fs.writeFileSync(