strata-storage 1.0.0

package/dist/adapters/capacitor/FilesystemAdapter.js

@@ -0,0 +1,162 @@
+/**
+ * Filesystem Adapter - Native file system storage
+ * Direct file access on iOS and Android
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { StrataStorage } from '@/plugin';
+import { StorageError } from '@/utils/errors';
+import { isCapacitor } from '@/utils';
+/**
+ * Native filesystem adapter using Capacitor plugin
+ */
+export class FilesystemAdapter extends BaseAdapter {
+    name = 'filesystem';
+    capabilities = {
+        persistent: true,
+        synchronous: false,
+        observable: false,
+        transactional: false,
+        queryable: true,
+        maxSize: -1, // Limited by device storage
+        binary: true, // Supports binary files
+        encrypted: false,
+        crossTab: true,
+    };
+    /**
+     * Check if filesystem is available
+     */
+    async isAvailable() {
+        if (!isCapacitor())
+            return false;
+        try {
+            const result = await StrataStorage.isAvailable({ storage: 'filesystem' });
+            return result.available;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize() {
+        this.startTTLCleanup();
+    }
+    /**
+     * Get a value from filesystem
+     */
+    async get(key) {
+        try {
+            const result = await StrataStorage.get({
+                key,
+                storage: 'filesystem',
+            });
+            if (!result.value)
+                return null;
+            const value = result.value;
+            // Check TTL
+            if (this.isExpired(value)) {
+                await this.remove(key);
+                return null;
+            }
+            return value;
+        }
+        catch (error) {
+            console.error(`Failed to get key ${key} from filesystem:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in filesystem
+     */
+    async set(key, value) {
+        const oldValue = await this.get(key);
+        try {
+            await StrataStorage.set({
+                key,
+                value,
+                storage: 'filesystem',
+            });
+            this.emitChange(key, oldValue?.value, value.value, 'local');
+        }
+        catch (error) {
+            throw new StorageError(`Failed to set key ${key} in filesystem: ${error}`);
+        }
+    }
+    /**
+     * Remove a value from filesystem
+     */
+    async remove(key) {
+        const oldValue = await this.get(key);
+        try {
+            await StrataStorage.remove({
+                key,
+                storage: 'filesystem',
+            });
+            if (oldValue) {
+                this.emitChange(key, oldValue.value, undefined, 'local');
+            }
+        }
+        catch (error) {
+            throw new StorageError(`Failed to remove key ${key} from filesystem: ${error}`);
+        }
+    }
+    /**
+     * Clear filesystem storage
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            try {
+                await StrataStorage.clear({
+                    storage: 'filesystem',
+                });
+                this.emitChange('*', undefined, undefined, 'local');
+                return;
+            }
+            catch (error) {
+                throw new StorageError(`Failed to clear filesystem: ${error}`);
+            }
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        try {
+            const result = await StrataStorage.keys({
+                storage: 'filesystem',
+                pattern: pattern instanceof RegExp ? pattern.source : pattern,
+            });
+            const keys = result.keys;
+            // Check for expired keys
+            const validKeys = [];
+            for (const key of keys) {
+                const value = await this.get(key);
+                if (value) {
+                    validKeys.push(key);
+                }
+            }
+            return this.filterKeys(validKeys, pattern);
+        }
+        catch (error) {
+            throw new StorageError(`Failed to get keys from filesystem: ${error}`);
+        }
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        try {
+            const result = await StrataStorage.size({
+                storage: 'filesystem',
+                detailed,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new StorageError(`Failed to get size of filesystem: ${error}`);
+        }
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreferencesAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/capacitor/PreferencesAdapter.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,kBAAmB,SAAQ,WAAW;IACjD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAiB;IAC3C,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"}

package/dist/adapters/capacitor/PreferencesAdapter.js

@@ -0,0 +1,162 @@
+/**
+ * Preferences Adapter - Native preferences storage
+ * iOS: UserDefaults, Android: SharedPreferences
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { StrataStorage } from '@/plugin';
+import { StorageError } from '@/utils/errors';
+import { isCapacitor } from '@/utils';
+/**
+ * Native preferences adapter using Capacitor plugin
+ */
+export class PreferencesAdapter extends BaseAdapter {
+    name = 'preferences';
+    capabilities = {
+        persistent: true,
+        synchronous: false,
+        observable: false, // No native change events
+        transactional: false,
+        queryable: true,
+        maxSize: -1, // Platform dependent
+        binary: false, // Only JSON-serializable data
+        encrypted: false,
+        crossTab: true, // Shared across app
+    };
+    /**
+     * Check if preferences are available
+     */
+    async isAvailable() {
+        if (!isCapacitor())
+            return false;
+        try {
+            const result = await StrataStorage.isAvailable({ storage: 'preferences' });
+            return result.available;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize() {
+        this.startTTLCleanup();
+    }
+    /**
+     * Get a value from preferences
+     */
+    async get(key) {
+        try {
+            const result = await StrataStorage.get({
+                key,
+                storage: 'preferences',
+            });
+            if (!result.value)
+                return null;
+            const value = result.value;
+            // Check TTL
+            if (this.isExpired(value)) {
+                await this.remove(key);
+                return null;
+            }
+            return value;
+        }
+        catch (error) {
+            console.error(`Failed to get key ${key} from preferences:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in preferences
+     */
+    async set(key, value) {
+        const oldValue = await this.get(key);
+        try {
+            await StrataStorage.set({
+                key,
+                value,
+                storage: 'preferences',
+            });
+            this.emitChange(key, oldValue?.value, value.value, 'local');
+        }
+        catch (error) {
+            throw new StorageError(`Failed to set key ${key} in preferences: ${error}`);
+        }
+    }
+    /**
+     * Remove a value from preferences
+     */
+    async remove(key) {
+        const oldValue = await this.get(key);
+        try {
+            await StrataStorage.remove({
+                key,
+                storage: 'preferences',
+            });
+            if (oldValue) {
+                this.emitChange(key, oldValue.value, undefined, 'local');
+            }
+        }
+        catch (error) {
+            throw new StorageError(`Failed to remove key ${key} from preferences: ${error}`);
+        }
+    }
+    /**
+     * Clear preferences
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            try {
+                await StrataStorage.clear({
+                    storage: 'preferences',
+                });
+                this.emitChange('*', undefined, undefined, 'local');
+                return;
+            }
+            catch (error) {
+                throw new StorageError(`Failed to clear preferences: ${error}`);
+            }
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        try {
+            const result = await StrataStorage.keys({
+                storage: 'preferences',
+                pattern: pattern instanceof RegExp ? pattern.source : pattern,
+            });
+            const keys = result.keys;
+            // Check for expired keys
+            const validKeys = [];
+            for (const key of keys) {
+                const value = await this.get(key);
+                if (value) {
+                    validKeys.push(key);
+                }
+            }
+            return this.filterKeys(validKeys, pattern);
+        }
+        catch (error) {
+            throw new StorageError(`Failed to get keys from preferences: ${error}`);
+        }
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        try {
+            const result = await StrataStorage.size({
+                storage: 'preferences',
+                detailed,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new StorageError(`Failed to get size of preferences: ${error}`);
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Secure Adapter - Native secure storage
+ * iOS: Keychain, Android: EncryptedSharedPreferences
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import type { StorageType, StorageCapabilities, StorageValue, ClearOptions, SizeInfo } from '@/types';
+/**
+ * Native secure storage adapter using Capacitor plugin
+ */
+export declare class SecureAdapter extends BaseAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    /**
+     * Check if secure storage is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Initialize the adapter
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get a value from secure storage
+     */
+    get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    /**
+     * Set a value in secure storage
+     */
+    set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from secure storage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear secure storage
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Get storage size
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+    /**
+     * iOS-specific: Store in Keychain with options
+     */
+    setKeychainItem(key: string, value: string, options?: {
+        service?: string;
+        accessGroup?: string;
+        accessible?: import('@/plugin/definitions').KeychainAccessible;
+    }): Promise<void>;
+    /**
+     * iOS-specific: Get from Keychain
+     */
+    getKeychainItem(key: string, options?: {
+        service?: string;
+        accessGroup?: string;
+    }): Promise<string | null>;
+    /**
+     * Android-specific: Store encrypted preference
+     */
+    setEncryptedPreference(key: string, value: unknown, fileName?: string): Promise<void>;
+    /**
+     * Android-specific: Get encrypted preference
+     */
+    getEncryptedPreference(key: string, fileName?: string): Promise<unknown>;
+}
+//# sourceMappingURL=SecureAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SecureAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/capacitor/SecureAdapter.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,aAAc,SAAQ,WAAW;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAY;IACtC,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;IAajD;;OAEG;IACG,eAAe,CACnB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,sBAAsB,EAAE,kBAAkB,CAAC;KAChE,GACA,OAAO,CAAC,IAAI,CAAC;IAYhB;;OAEG;IACG,eAAe,CACnB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GACA,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAazB;;OAEG;IACG,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY3F;;OAEG;IACG,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAY/E"}

package/dist/adapters/capacitor/SecureAdapter.js

@@ -0,0 +1,214 @@
+/**
+ * Secure Adapter - Native secure storage
+ * iOS: Keychain, Android: EncryptedSharedPreferences
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { StrataStorage } from '@/plugin';
+import { StorageError } from '@/utils/errors';
+import { isCapacitor } from '@/utils';
+/**
+ * Native secure storage adapter using Capacitor plugin
+ */
+export class SecureAdapter extends BaseAdapter {
+    name = 'secure';
+    capabilities = {
+        persistent: true,
+        synchronous: false,
+        observable: false,
+        transactional: false,
+        queryable: true,
+        maxSize: -1, // Platform dependent
+        binary: false, // String data only
+        encrypted: true, // Native encryption
+        crossTab: true,
+    };
+    /**
+     * Check if secure storage is available
+     */
+    async isAvailable() {
+        if (!isCapacitor())
+            return false;
+        try {
+            const result = await StrataStorage.isAvailable({ storage: 'secure' });
+            return result.available;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize() {
+        this.startTTLCleanup();
+    }
+    /**
+     * Get a value from secure storage
+     */
+    async get(key) {
+        try {
+            const result = await StrataStorage.get({
+                key,
+                storage: 'secure',
+            });
+            if (!result.value)
+                return null;
+            const value = result.value;
+            // Check TTL
+            if (this.isExpired(value)) {
+                await this.remove(key);
+                return null;
+            }
+            return value;
+        }
+        catch (error) {
+            console.error(`Failed to get key ${key} from secure storage:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in secure storage
+     */
+    async set(key, value) {
+        const oldValue = await this.get(key);
+        try {
+            await StrataStorage.set({
+                key,
+                value,
+                storage: 'secure',
+            });
+            this.emitChange(key, oldValue?.value, value.value, 'local');
+        }
+        catch (error) {
+            throw new StorageError(`Failed to set key ${key} in secure storage: ${error}`);
+        }
+    }
+    /**
+     * Remove a value from secure storage
+     */
+    async remove(key) {
+        const oldValue = await this.get(key);
+        try {
+            await StrataStorage.remove({
+                key,
+                storage: 'secure',
+            });
+            if (oldValue) {
+                this.emitChange(key, oldValue.value, undefined, 'local');
+            }
+        }
+        catch (error) {
+            throw new StorageError(`Failed to remove key ${key} from secure storage: ${error}`);
+        }
+    }
+    /**
+     * Clear secure storage
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            try {
+                await StrataStorage.clear({
+                    storage: 'secure',
+                });
+                this.emitChange('*', undefined, undefined, 'local');
+                return;
+            }
+            catch (error) {
+                throw new StorageError(`Failed to clear secure storage: ${error}`);
+            }
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        try {
+            const result = await StrataStorage.keys({
+                storage: 'secure',
+                pattern: pattern instanceof RegExp ? pattern.source : pattern,
+            });
+            const keys = result.keys;
+            // Check for expired keys
+            const validKeys = [];
+            for (const key of keys) {
+                const value = await this.get(key);
+                if (value) {
+                    validKeys.push(key);
+                }
+            }
+            return this.filterKeys(validKeys, pattern);
+        }
+        catch (error) {
+            throw new StorageError(`Failed to get keys from secure storage: ${error}`);
+        }
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        try {
+            const result = await StrataStorage.size({
+                storage: 'secure',
+                detailed,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new StorageError(`Failed to get size of secure storage: ${error}`);
+        }
+    }
+    /**
+     * iOS-specific: Store in Keychain with options
+     */
+    async setKeychainItem(key, value, options) {
+        if (!StrataStorage.setKeychain) {
+            throw new StorageError('Keychain not available on this platform');
+        }
+        await StrataStorage.setKeychain({
+            key,
+            value,
+            ...options,
+        });
+    }
+    /**
+     * iOS-specific: Get from Keychain
+     */
+    async getKeychainItem(key, options) {
+        if (!StrataStorage.getKeychain) {
+            throw new StorageError('Keychain not available on this platform');
+        }
+        const result = await StrataStorage.getKeychain({
+            key,
+            ...options,
+        });
+        return result.value;
+    }
+    /**
+     * Android-specific: Store encrypted preference
+     */
+    async setEncryptedPreference(key, value, fileName) {
+        if (!StrataStorage.setEncryptedPreference) {
+            throw new StorageError('Encrypted preferences not available on this platform');
+        }
+        await StrataStorage.setEncryptedPreference({
+            key,
+            value,
+            fileName,
+        });
+    }
+    /**
+     * Android-specific: Get encrypted preference
+     */
+    async getEncryptedPreference(key, fileName) {
+        if (!StrataStorage.getEncryptedPreference) {
+            throw new StorageError('Encrypted preferences not available on this platform');
+        }
+        const result = await StrataStorage.getEncryptedPreference({
+            key,
+            fileName,
+        });
+        return result.value;
+    }
+}