strata-storage 2.6.1 → 2.7.0

package/dist/ios/Plugin/KeychainStorage.swift

@@ -1,233 +0,0 @@
-import Foundation
-import Security
-
-/**
- * Keychain-backed secure storage.
- *
- * Security notes:
- * - Items default to `kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly`,
- *   which keeps data available to background tasks after the first unlock
- *   while preventing it from leaving the device via encrypted backups.
- *   `kSecAttrAccessibleAlways` / `kSecAttrAccessibleAlwaysThisDeviceOnly`
- *   are deprecated and insecure and are intentionally NOT used.
- * - Callers may pass a stricter accessibility class from JS via the
- *   `accessible` option (see KeychainAccessible in definitions.ts).
- * - Secret values are never logged.
- */
-@objc public class KeychainStorage: NSObject {
-    private let service: String
-    private let accessGroup: String?
-    private let defaultAccessible: CFString
-
-    @objc public init(service: String? = nil, accessGroup: String? = nil) {
-        self.service = service ?? Bundle.main.bundleIdentifier ?? "StrataStorage"
-        self.accessGroup = accessGroup
-        // After-first-unlock + this-device-only is a safe, widely-recommended
-        // default for app secrets. It is more permissive than whenUnlocked
-        // (so background access works) but still excluded from backups.
-        self.defaultAccessible = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
-        super.init()
-    }
-
-    /// Maps a JS `KeychainAccessible` string to the matching Security framework
-    /// constant. Unknown / nil values fall back to the secure default.
-    private func accessibleConstant(for raw: String?) -> CFString {
-        switch raw {
-        case "whenUnlocked":
-            return kSecAttrAccessibleWhenUnlocked
-        case "afterFirstUnlock":
-            return kSecAttrAccessibleAfterFirstUnlock
-        case "whenUnlockedThisDeviceOnly":
-            return kSecAttrAccessibleWhenUnlockedThisDeviceOnly
-        case "afterFirstUnlockThisDeviceOnly":
-            return kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
-        case "whenPasscodeSetThisDeviceOnly":
-            return kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly
-        default:
-            return defaultAccessible
-        }
-    }
-
-    /// Builds an NSError that surfaces the OSStatus to the JS bridge without
-    /// leaking any stored secret value.
-    private func keychainError(_ status: OSStatus, operation: String) -> NSError {
-        let message: String
-        if #available(iOS 11.3, *), let str = SecCopyErrorMessageString(status, nil) as String? {
-            message = str
-        } else {
-            message = "OSStatus \(status)"
-        }
-        return NSError(
-            domain: "StrataStorage.KeychainStorage",
-            code: Int(status),
-            userInfo: [NSLocalizedDescriptionKey: "Keychain \(operation) failed: \(message)"]
-        )
-    }
-
-    @objc public func set(key: String, value: Any, accessible: String? = nil) throws -> Bool {
-        let data: Data
-
-        if let dataValue = value as? Data {
-            data = dataValue
-        } else if let stringValue = value as? String {
-            data = stringValue.data(using: .utf8) ?? Data()
-        } else {
-            // Convert to JSON for complex objects
-            let jsonData = try JSONSerialization.data(withJSONObject: value, options: [])
-            data = jsonData
-        }
-
-        // Remove any existing item first so the accessibility class is applied
-        // cleanly (SecItemUpdate cannot change accessibility reliably).
-        let deleteQuery = createQuery(key: key)
-        SecItemDelete(deleteQuery as CFDictionary)
-
-        var newItem = createQuery(key: key, accessible: accessibleConstant(for: accessible))
-        newItem[kSecValueData as String] = data
-
-        let status = SecItemAdd(newItem as CFDictionary, nil)
-        guard status == errSecSuccess else {
-            throw keychainError(status, operation: "set")
-        }
-        return true
-    }
-
-    // Convenience overload kept for existing Objective-C callers.
-    @objc public func set(key: String, value: Any) throws -> Bool {
-        return try set(key: key, value: value, accessible: nil)
-    }
-
-    @objc public func get(key: String) throws -> Any? {
-        var query = createQuery(key: key)
-        query[kSecReturnData as String] = true
-        query[kSecMatchLimit as String] = kSecMatchLimitOne
-
-        var result: AnyObject?
-        let status = SecItemCopyMatching(query as CFDictionary, &result)
-
-        if status == errSecItemNotFound {
-            return nil
-        }
-        guard status == errSecSuccess else {
-            throw keychainError(status, operation: "get")
-        }
-        guard let data = result as? Data else { return nil }
-
-        // Try to parse as JSON first, fallback to string
-        if let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) {
-            return jsonObject
-        } else {
-            return String(data: data, encoding: .utf8)
-        }
-    }
-
-    @objc public func remove(key: String) throws -> Bool {
-        let query = createQuery(key: key)
-        let status = SecItemDelete(query as CFDictionary)
-        guard status == errSecSuccess || status == errSecItemNotFound else {
-            throw keychainError(status, operation: "remove")
-        }
-        return true
-    }
-
-    @objc public func clear(prefix: String? = nil) throws -> Bool {
-        if let prefix = prefix {
-            // Clear only keys with the given prefix
-            let keysToRemove = try keys(pattern: prefix)
-            for key in keysToRemove {
-                _ = try remove(key: key)
-            }
-            return true
-        } else {
-            // Clear all keys for this service (and access group, if any).
-            var query: [String: Any] = [
-                kSecClass as String: kSecClassGenericPassword,
-                kSecAttrService as String: service
-            ]
-            if let accessGroup = accessGroup {
-                query[kSecAttrAccessGroup as String] = accessGroup
-            }
-            let status = SecItemDelete(query as CFDictionary)
-            guard status == errSecSuccess || status == errSecItemNotFound else {
-                throw keychainError(status, operation: "clear")
-            }
-            return true
-        }
-    }
-
-    @objc public func keys(pattern: String? = nil) throws -> [String] {
-        var query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecReturnAttributes as String: true,
-            kSecMatchLimit as String: kSecMatchLimitAll
-        ]
-
-        if let accessGroup = accessGroup {
-            query[kSecAttrAccessGroup as String] = accessGroup
-        }
-
-        var result: AnyObject?
-        let status = SecItemCopyMatching(query as CFDictionary, &result)
-
-        if status == errSecItemNotFound {
-            return []
-        }
-        guard status == errSecSuccess,
-              let items = result as? [[String: Any]] else {
-            if status == errSecSuccess { return [] }
-            throw keychainError(status, operation: "keys")
-        }
-
-        let allKeys = items.compactMap { $0[kSecAttrAccount as String] as? String }
-
-        guard let pattern = pattern else {
-            return allKeys
-        }
-
-        // Filter keys by pattern (simple prefix / contains matching)
-        return allKeys.filter { key in
-            key.hasPrefix(pattern) || key.contains(pattern)
-        }
-    }
-
-    private func createQuery(key: String, accessible: CFString? = nil) -> [String: Any] {
-        var query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key
-        ]
-
-        // Accessibility only needs to be set when adding/writing an item.
-        // Including it on read/delete queries can over-constrain matching.
-        if let accessible = accessible {
-            query[kSecAttrAccessible as String] = accessible
-        }
-
-        if let accessGroup = accessGroup {
-            query[kSecAttrAccessGroup as String] = accessGroup
-        }
-
-        return query
-    }
-
-    @objc public func size() throws -> (total: Int, count: Int) {
-        let allKeys = try keys()
-        var totalSize = 0
-
-        for key in allKeys {
-            if let value = try get(key: key) {
-                if let data = value as? Data {
-                    totalSize += data.count
-                } else if let string = value as? String {
-                    totalSize += string.data(using: .utf8)?.count ?? 0
-                } else if let jsonData = try? JSONSerialization.data(withJSONObject: value, options: []) {
-                    totalSize += jsonData.count
-                }
-            }
-            totalSize += key.data(using: .utf8)?.count ?? 0
-        }
-
-        return (total: totalSize, count: allKeys.count)
-    }
-}

package/dist/ios/Plugin/SQLiteStorage.swift

@@ -1,426 +0,0 @@
-import Foundation
-import SQLite3
-import os.log
-
-/// SQLITE_TRANSIENT tells SQLite to copy bound bytes immediately, which is
-/// required when binding Swift `String`/`Data` whose buffers may be freed
-/// before `sqlite3_step` runs. Passing `nil` (SQLITE_STATIC) here is a
-/// use-after-free hazard for transient Swift buffers.
-private let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
-
-/**
- * SQLite-backed storage for one `(database, table)` pair.
- *
- * Multi-store design:
- * - One `SQLiteStorage` instance owns one open DB handle for one database file.
- * - A single instance can serve many tables in that file; tables are created
- *   on first use (see `ensureTable`).
- * - The plugin caches one instance per database filename (see
- *   `SQLiteStorageManager`) so the DB is opened once, not per call.
- *
- * Value-shape contract (matches src/plugin/definitions.ts):
- * - `set` receives the FULL `StorageValue` wrapper object
- *   `{ value, created, updated, expires?, tags?, metadata?, ... }`. The whole
- *   wrapper is JSON-serialized into the `value` column for a perfect
- *   round-trip. `created`/`updated`/`expires`/`tags`/`metadata` are ALSO
- *   mirrored into dedicated columns so native TTL cleanup + `query` can use
- *   them without re-parsing the blob.
- * - `get` parses the `value` column bytes back into the wrapper object and the
- *   plugin resolves `{ value: wrapper }`. Corrupt/legacy bytes that do not
- *   parse as a JSON object are treated as a miss (never a crash).
- *
- * SQL-safety: only the table identifier is interpolated into SQL, and it is
- * pre-sanitized to `^[A-Za-z0-9_]+$` by the plugin. All user values are bound
- * parameters.
- */
-@objc public class SQLiteStorage: NSObject {
-    private var db: OpaquePointer?
-    private let dbName: String
-    /// Tables already verified/created on this handle, to skip redundant DDL.
-    private var ensuredTables: Set<String> = []
-    private let logger = OSLog(subsystem: "com.strata.storage", category: "SQLiteStorage")
-
-    /// Opens (or creates) the database file `<dbName>` under Documents.
-    /// `dbName` MUST already be a sanitized filename (e.g. `storage.db`).
-    @objc public init(dbName: String = "strata_storage.db") {
-        self.dbName = dbName
-        super.init()
-        do {
-            try openDatabase()
-        } catch {
-            os_log("Failed to initialize SQLite storage: %{public}@", log: logger, type: .error, error.localizedDescription)
-        }
-    }
-
-    deinit {
-        closeDatabase()
-    }
-
-    private func openDatabase() throws {
-        guard let fileURL = try? FileManager.default
-            .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
-            .appendingPathComponent(dbName) else {
-            throw NSError(
-                domain: "StrataStorage.SQLiteStorage",
-                code: 1001,
-                userInfo: [NSLocalizedDescriptionKey: "Unable to access document directory"]
-            )
-        }
-
-        guard sqlite3_open(fileURL.path, &db) == SQLITE_OK else {
-            let errorMessage = String(cString: sqlite3_errmsg(db))
-            sqlite3_close(db)
-            db = nil
-            throw NSError(
-                domain: "StrataStorage.SQLiteStorage",
-                code: 1002,
-                userInfo: [NSLocalizedDescriptionKey: "Unable to open database: \(errorMessage)"]
-            )
-        }
-    }
-
-    private func closeDatabase() {
-        if db != nil {
-            sqlite3_close(db)
-            db = nil
-        }
-    }
-
-    /// Creates the table for `table` if it does not exist yet. Cached per
-    /// instance so repeated calls are cheap. `table` MUST be pre-sanitized.
-    private func ensureTable(_ table: String) throws {
-        guard let db = db else {
-            throw notInitializedError()
-        }
-        if ensuredTables.contains(table) { return }
-
-        let createTableString = """
-            CREATE TABLE IF NOT EXISTS \(table) (
-                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?
-        defer { sqlite3_finalize(createTableStatement) }
-
-        guard sqlite3_prepare_v2(db, createTableString, -1, &createTableStatement, nil) == SQLITE_OK else {
-            let errorMessage = String(cString: sqlite3_errmsg(db))
-            throw NSError(
-                domain: "StrataStorage.SQLiteStorage",
-                code: 1003,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to prepare CREATE TABLE: \(errorMessage)"]
-            )
-        }
-
-        guard sqlite3_step(createTableStatement) == SQLITE_DONE else {
-            let errorMessage = String(cString: sqlite3_errmsg(db))
-            throw NSError(
-                domain: "StrataStorage.SQLiteStorage",
-                code: 1004,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to create table: \(errorMessage)"]
-            )
-        }
-
-        ensuredTables.insert(table)
-    }
-
-    private func notInitializedError() -> NSError {
-        return NSError(
-            domain: "StrataStorage.SQLiteStorage",
-            code: 1000,
-            userInfo: [NSLocalizedDescriptionKey: "Database not initialized"]
-        )
-    }
-
-    /**
-     * Persist a full `StorageValue` wrapper for `key` in `table`.
-     *
-     * The entire `wrapper` dictionary is JSON-encoded into the `value` column
-     * (perfect round-trip). `created`/`updated`/`expires` and the JSON of
-     * `tags`/`metadata` are extracted into their own columns for TTL + query.
-     * Values are bound parameters; only `table` is interpolated (pre-sanitized).
-     */
-    @objc public func set(table: String, key: String, wrapper: [String: Any]) throws -> Bool {
-        guard let db = db else { throw notInitializedError() }
-        try ensureTable(table)
-
-        // Serialize the whole wrapper for round-trip storage.
-        let blob = try JSONSerialization.data(withJSONObject: wrapper, options: [])
-
-        // Extract mirror columns from the wrapper. created/updated are required
-        // by the wrapper contract; fall back to "now" defensively.
-        let now = Int64(Date().timeIntervalSince1970 * 1000)
-        let created = (wrapper["created"] as? NSNumber)?.int64Value ?? now
-        let updated = (wrapper["updated"] as? NSNumber)?.int64Value ?? now
-        let expires = (wrapper["expires"] as? NSNumber)?.int64Value
-
-        let tagsData: Data?
-        if let tags = wrapper["tags"] {
-            tagsData = try? JSONSerialization.data(withJSONObject: tags, options: [])
-        } else {
-            tagsData = nil
-        }
-
-        let metadataData: Data?
-        if let metadata = wrapper["metadata"] {
-            metadataData = try? JSONSerialization.data(withJSONObject: metadata, options: [])
-        } else {
-            metadataData = nil
-        }
-
-        let insertSQL = """
-            INSERT OR REPLACE INTO \(table)
-            (key, value, created, updated, expires, tags, metadata)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        """
-
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-
-        guard sqlite3_prepare_v2(db, insertSQL, -1, &statement, nil) == SQLITE_OK else {
-            return false
-        }
-
-        let ok =
-            sqlite3_bind_text(statement, 1, key, -1, SQLITE_TRANSIENT) == SQLITE_OK &&
-            blob.withUnsafeBytes { sqlite3_bind_blob(statement, 2, $0.baseAddress, Int32(blob.count), SQLITE_TRANSIENT) } == SQLITE_OK &&
-            sqlite3_bind_int64(statement, 3, created) == SQLITE_OK &&
-            sqlite3_bind_int64(statement, 4, updated) == SQLITE_OK &&
-            (expires != nil ? sqlite3_bind_int64(statement, 5, expires!) : sqlite3_bind_null(statement, 5)) == SQLITE_OK &&
-            bindOptionalBlob(statement, 6, tagsData) == SQLITE_OK &&
-            bindOptionalBlob(statement, 7, metadataData) == SQLITE_OK
-
-        guard ok else { return false }
-        return sqlite3_step(statement) == SQLITE_DONE
-    }
-
-    /// Binds `data` as a blob to `index`, or NULL when `data` is nil.
-    private func bindOptionalBlob(_ statement: OpaquePointer?, _ index: Int32, _ data: Data?) -> Int32 {
-        guard let data = data else {
-            return sqlite3_bind_null(statement, index)
-        }
-        return data.withUnsafeBytes {
-            sqlite3_bind_blob(statement, index, $0.baseAddress, Int32(data.count), SQLITE_TRANSIENT)
-        }
-    }
-
-    /**
-     * Read the wrapper object for `key` from `table`.
-     *
-     * Returns the decoded `StorageValue` wrapper dictionary, or `nil` for a
-     * missing row OR when stored bytes do not parse as a JSON object
-     * (legacy/corrupt data is treated as a miss, never a crash).
-     */
-    @objc public func get(table: String, key: String) -> [String: Any]? {
-        guard let db = db else {
-            os_log("Database not initialized", log: logger, type: .error)
-            return nil
-        }
-        // Reading a table that was never created is a miss, not an error.
-        try? ensureTable(table)
-
-        let querySQL = "SELECT value FROM \(table) WHERE key = ? LIMIT 1"
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-
-        guard sqlite3_prepare_v2(db, querySQL, -1, &statement, nil) == SQLITE_OK,
-              sqlite3_bind_text(statement, 1, key, -1, SQLITE_TRANSIENT) == SQLITE_OK else {
-            return nil
-        }
-
-        guard sqlite3_step(statement) == SQLITE_ROW,
-              let blob = sqlite3_column_blob(statement, 0) else {
-            return nil
-        }
-
-        let valueData = Data(bytes: blob, count: Int(sqlite3_column_bytes(statement, 0)))
-        // The wrapper is always a JSON object. Anything else = legacy/corrupt → miss.
-        guard let wrapper = try? JSONSerialization.jsonObject(with: valueData, options: []) as? [String: Any] else {
-            return nil
-        }
-        return wrapper
-    }
-
-    @objc public func remove(table: String, key: String) -> Bool {
-        guard let db = db else {
-            os_log("Database not initialized", log: logger, type: .error)
-            return false
-        }
-        try? ensureTable(table)
-
-        let deleteSQL = "DELETE FROM \(table) WHERE key = ?"
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-
-        guard sqlite3_prepare_v2(db, deleteSQL, -1, &statement, nil) == SQLITE_OK,
-              sqlite3_bind_text(statement, 1, key, -1, SQLITE_TRANSIENT) == SQLITE_OK else {
-            return false
-        }
-        return sqlite3_step(statement) == SQLITE_DONE
-    }
-
-    @objc public func clear(table: String, prefix: String? = nil) -> Bool {
-        guard let db = db else {
-            os_log("Database not initialized", log: logger, type: .error)
-            return false
-        }
-        try? ensureTable(table)
-
-        let deleteSQL: String
-        if prefix != nil {
-            deleteSQL = "DELETE FROM \(table) WHERE key LIKE ?"
-        } else {
-            deleteSQL = "DELETE FROM \(table)"
-        }
-
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-
-        guard sqlite3_prepare_v2(db, deleteSQL, -1, &statement, nil) == SQLITE_OK else {
-            return false
-        }
-        if let prefix = prefix {
-            guard sqlite3_bind_text(statement, 1, "\(prefix)%", -1, SQLITE_TRANSIENT) == SQLITE_OK else {
-                return false
-            }
-        }
-        return sqlite3_step(statement) == SQLITE_DONE
-    }
-
-    @objc public func keys(table: String, pattern: String? = nil) -> [String] {
-        guard let db = db else {
-            os_log("Database not initialized", log: logger, type: .error)
-            return []
-        }
-        try? ensureTable(table)
-
-        let querySQL: String
-        if pattern != nil {
-            querySQL = "SELECT key FROM \(table) WHERE key LIKE ?"
-        } else {
-            querySQL = "SELECT key FROM \(table)"
-        }
-
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-        var keys: [String] = []
-
-        if sqlite3_prepare_v2(db, querySQL, -1, &statement, nil) == SQLITE_OK {
-            if let pattern = pattern {
-                // `%pattern%` mirrors the contains-matching used by other backends.
-                sqlite3_bind_text(statement, 1, "%\(pattern)%", -1, SQLITE_TRANSIENT)
-            }
-            while sqlite3_step(statement) == SQLITE_ROW {
-                if let key = sqlite3_column_text(statement, 0) {
-                    keys.append(String(cString: key))
-                }
-            }
-        }
-        return keys
-    }
-
-    /**
-     * Aggregate sizes for `table`.
-     *
-     * Returns `count`, `total` (= `keys` + `values`), and per-segment byte
-     * sums: `keys` = SUM(LENGTH(key)), `values` = SUM(LENGTH(value)),
-     * `metadata` = SUM(LENGTH(metadata)) treating NULL as 0. The plugin decides
-     * whether to surface the `detailed` segment based on the `detailed` flag.
-     */
-    @objc public func size(table: String) throws -> [String: Int] {
-        guard let db = db else { throw notInitializedError() }
-        try ensureTable(table)
-
-        let querySQL = """
-            SELECT COUNT(*),
-                   COALESCE(SUM(LENGTH(key)), 0),
-                   COALESCE(SUM(LENGTH(value)), 0),
-                   COALESCE(SUM(LENGTH(metadata)), 0)
-            FROM \(table)
-        """
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-
-        var count = 0
-        var keysSize = 0
-        var valuesSize = 0
-        var metadataSize = 0
-
-        if sqlite3_prepare_v2(db, querySQL, -1, &statement, nil) == SQLITE_OK,
-           sqlite3_step(statement) == SQLITE_ROW {
-            count = Int(sqlite3_column_int(statement, 0))
-            keysSize = Int(sqlite3_column_int64(statement, 1))
-            valuesSize = Int(sqlite3_column_int64(statement, 2))
-            metadataSize = Int(sqlite3_column_int64(statement, 3))
-        }
-
-        return [
-            "count": count,
-            "keys": keysSize,
-            "values": valuesSize,
-            "metadata": metadataSize,
-            "total": keysSize + valuesSize
-        ]
-    }
-
-    /**
-     * Returns every row as `{ key }`. The JS SqliteAdapter applies the real
-     * query `condition` by re-fetching and filtering each key, so this native
-     * side only needs to enumerate candidate keys. The `condition` argument is
-     * accepted for forward-compatibility but is not yet pushed down into SQL.
-     */
-    @objc public func query(table: String, condition: [String: Any]) -> [[String: Any]] {
-        guard let db = db else {
-            os_log("Database not initialized", log: logger, type: .error)
-            return []
-        }
-        try? ensureTable(table)
-
-        let querySQL = "SELECT key FROM \(table)"
-        var statement: OpaquePointer?
-        defer { sqlite3_finalize(statement) }
-        var rows: [[String: Any]] = []
-
-        if sqlite3_prepare_v2(db, querySQL, -1, &statement, nil) == SQLITE_OK {
-            while sqlite3_step(statement) == SQLITE_ROW {
-                guard let keyCString = sqlite3_column_text(statement, 0) else { continue }
-                rows.append(["key": String(cString: keyCString)])
-            }
-        }
-        return rows
-    }
-}
-
-/**
- * Caches one open `SQLiteStorage` (and thus one DB handle) per database
- * filename, so the database is opened once per file instead of on every
- * bridge call. Access is serialized with a lock because Capacitor may dispatch
- * plugin calls on a background queue.
- */
-final class SQLiteStorageManager {
-    static let shared = SQLiteStorageManager()
-
-    private var stores: [String: SQLiteStorage] = [:]
-    private let lock = NSLock()
-
-    private init() {}
-
-    /// Returns the cached store for `fileName` (e.g. `storage.db`), creating it
-    /// on first use. `fileName` MUST already be sanitized.
-    func store(forFile fileName: String) -> SQLiteStorage {
-        lock.lock()
-        defer { lock.unlock() }
-        if let existing = stores[fileName] {
-            return existing
-        }
-        let created = SQLiteStorage(dbName: fileName)
-        stores[fileName] = created
-        return created
-    }
-}

package/dist/ios/Plugin/StrataStoragePlugin.m

@@ -1,23 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <Capacitor/Capacitor.h>
-
-// Registers the StrataStorage plugin and its methods with the Capacitor
-// bridge. Without this macro block the @objc Swift methods are NOT exposed
-// to the JavaScript layer and every call would fail with "method not
-// implemented". The method names and the parameter list below MUST match
-// the @objc func names in StrataStoragePlugin.swift and the JS plugin
-// contract in src/plugin/definitions.ts.
-CAP_PLUGIN(StrataStoragePlugin, "StrataStorage",
-    CAP_PLUGIN_METHOD(isAvailable, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(get, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(set, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(remove, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(clear, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(keys, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(size, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(query, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(getUserDefaults, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(setUserDefaults, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(getKeychain, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(setKeychain, CAPPluginReturnPromise);
-)