strata-storage 1.0.0

package/dist/core/BaseAdapter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Base adapter implementation with common functionality
+ */
+import type { StorageAdapter, StorageValue, StorageType, StorageCapabilities, ClearOptions, SizeInfo, SubscriptionCallback, UnsubscribeFunction, QueryCondition } from '@/types';
+import { EventEmitter } from '@/utils';
+import { QueryEngine } from '@/features/query';
+/**
+ * Abstract base adapter that implements common functionality
+ */
+export declare abstract class BaseAdapter implements StorageAdapter {
+    abstract readonly name: StorageType;
+    abstract readonly capabilities: StorageCapabilities;
+    protected eventEmitter: EventEmitter;
+    protected queryEngine: QueryEngine;
+    protected ttlCleanupInterval?: ReturnType<typeof setInterval>;
+    protected ttlCheckInterval: number;
+    /**
+     * Initialize TTL cleanup if needed
+     */
+    protected startTTLCleanup(): void;
+    /**
+     * Stop TTL cleanup
+     */
+    protected stopTTLCleanup(): void;
+    /**
+     * Clean up expired items
+     */
+    protected cleanupExpired(): Promise<void>;
+    /**
+     * Check if value is expired
+     */
+    protected isExpired(value: StorageValue): boolean;
+    /**
+     * Filter keys by pattern
+     */
+    protected filterKeys(keys: string[], pattern?: string | RegExp): string[];
+    /**
+     * Calculate size of storage value
+     */
+    protected calculateSize(value: StorageValue): number;
+    /**
+     * Default has implementation using get
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Default clear implementation
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Default size implementation
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+    /**
+     * Subscribe to changes (if supported)
+     */
+    subscribe?(callback: SubscriptionCallback): UnsubscribeFunction;
+    /**
+     * Emit change event
+     */
+    protected emitChange(key: string, oldValue: unknown | undefined, newValue: unknown | undefined, source?: 'local' | 'remote'): void;
+    /**
+     * Query implementation (override in adapters that support it)
+     */
+    query?<T = unknown>(condition: QueryCondition): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    /**
+     * Close adapter (cleanup)
+     */
+    close?(): Promise<void>;
+    abstract isAvailable(): Promise<boolean>;
+    abstract initialize(config?: unknown): Promise<void>;
+    abstract get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    abstract set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    abstract remove(key: string): Promise<void>;
+    abstract keys(pattern?: string | RegExp): Promise<string[]>;
+}
+//# sourceMappingURL=BaseAdapter.d.ts.map

package/dist/core/BaseAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseAdapter.d.ts","sourceRoot":"","sources":["../../src/core/BaseAdapter.ts"],"names":[],"mappings":"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"}

package/dist/core/BaseAdapter.js

@@ -0,0 +1,197 @@
+/**
+ * Base adapter implementation with common functionality
+ */
+import { NotSupportedError } from '@/utils/errors';
+import { EventEmitter, matchGlob, getObjectSize } from '@/utils';
+import { QueryEngine } from '@/features/query';
+/**
+ * Abstract base adapter that implements common functionality
+ */
+export class BaseAdapter {
+    eventEmitter = new EventEmitter();
+    queryEngine = new QueryEngine();
+    ttlCleanupInterval;
+    ttlCheckInterval = 60000; // Check every minute
+    /**
+     * Initialize TTL cleanup if needed
+     */
+    startTTLCleanup() {
+        if (this.ttlCleanupInterval)
+            return;
+        this.ttlCleanupInterval = setInterval(async () => {
+            try {
+                await this.cleanupExpired();
+            }
+            catch (error) {
+                console.error(`TTL cleanup error in ${this.name}:`, error);
+            }
+        }, this.ttlCheckInterval);
+    }
+    /**
+     * Stop TTL cleanup
+     */
+    stopTTLCleanup() {
+        if (this.ttlCleanupInterval) {
+            clearInterval(this.ttlCleanupInterval);
+            this.ttlCleanupInterval = undefined;
+        }
+    }
+    /**
+     * Clean up expired items
+     */
+    async cleanupExpired() {
+        const now = Date.now();
+        const keys = await this.keys();
+        for (const key of keys) {
+            const item = await this.get(key);
+            if (item?.expires && item.expires <= now) {
+                await this.remove(key);
+            }
+        }
+    }
+    /**
+     * Check if value is expired
+     */
+    isExpired(value) {
+        if (!value.expires)
+            return false;
+        return Date.now() > value.expires;
+    }
+    /**
+     * Filter keys by pattern
+     */
+    filterKeys(keys, pattern) {
+        if (!pattern)
+            return keys;
+        if (pattern instanceof RegExp) {
+            return keys.filter((key) => pattern.test(key));
+        }
+        return keys.filter((key) => matchGlob(pattern, key));
+    }
+    /**
+     * Calculate size of storage value
+     */
+    calculateSize(value) {
+        return getObjectSize(value);
+    }
+    /**
+     * Default has implementation using get
+     */
+    async has(key) {
+        const value = await this.get(key);
+        return value !== null && !this.isExpired(value);
+    }
+    /**
+     * Default clear implementation
+     */
+    async clear(options) {
+        const keys = await this.keys();
+        for (const key of keys) {
+            let shouldDelete = true;
+            if (options?.pattern) {
+                shouldDelete = this.filterKeys([key], options.pattern).length > 0;
+            }
+            if (shouldDelete && options?.tags) {
+                const value = await this.get(key);
+                if (!value?.tags || !options.tags.some((tag) => value.tags?.includes(tag))) {
+                    shouldDelete = false;
+                }
+            }
+            if (shouldDelete && options?.expiredOnly) {
+                const value = await this.get(key);
+                if (!value || !this.isExpired(value)) {
+                    shouldDelete = false;
+                }
+            }
+            if (shouldDelete) {
+                await this.remove(key);
+            }
+        }
+    }
+    /**
+     * Default size implementation
+     */
+    async size(detailed) {
+        const keys = await this.keys();
+        let total = 0;
+        let keySize = 0;
+        let valueSize = 0;
+        let metadataSize = 0;
+        for (const key of keys) {
+            keySize += key.length * 2; // UTF-16
+            const item = await this.get(key);
+            if (item) {
+                const size = this.calculateSize(item);
+                valueSize += getObjectSize(item.value);
+                metadataSize += size - getObjectSize(item.value);
+                total += size;
+            }
+        }
+        const result = {
+            total: total + keySize,
+            count: keys.length,
+        };
+        if (detailed) {
+            result.detailed = {
+                keys: keySize,
+                values: valueSize,
+                metadata: metadataSize,
+            };
+        }
+        return result;
+    }
+    /**
+     * Subscribe to changes (if supported)
+     */
+    subscribe(callback) {
+        if (!this.capabilities.observable) {
+            throw new NotSupportedError('subscribe', this.name);
+        }
+        const handler = (...args) => {
+            const change = args[0];
+            callback(change);
+        };
+        this.eventEmitter.on('change', handler);
+        return () => {
+            this.eventEmitter.off('change', handler);
+        };
+    }
+    /**
+     * Emit change event
+     */
+    emitChange(key, oldValue, newValue, source = 'local') {
+        this.eventEmitter.emit('change', {
+            key,
+            oldValue,
+            newValue,
+            source,
+            storage: this.name,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Query implementation (override in adapters that support it)
+     */
+    async query(condition) {
+        if (!this.capabilities.queryable) {
+            throw new NotSupportedError('query', this.name);
+        }
+        // Basic implementation for adapters that don't have native query support
+        const results = [];
+        const keys = await this.keys();
+        for (const key of keys) {
+            const item = await this.get(key);
+            if (item && !this.isExpired(item) && this.queryEngine.matches(item.value, condition)) {
+                results.push({ key, value: item.value });
+            }
+        }
+        return results;
+    }
+    /**
+     * Close adapter (cleanup)
+     */
+    async close() {
+        this.stopTTLCleanup();
+        this.eventEmitter.removeAllListeners();
+    }
+}

package/dist/core/StorageStrategy.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Storage strategy implementation for automatic adapter selection
+ */
+import type { StorageAdapter, StorageType, StorageCapabilities } from '@/types';
+import { StorageStrategy } from '@/types';
+import { AdapterRegistry } from './AdapterRegistry';
+/**
+ * Strategy manager for selecting appropriate storage adapters
+ */
+export declare class StrategyManager {
+    private registry;
+    private strategy;
+    constructor(registry: AdapterRegistry, strategy?: StorageStrategy);
+    /**
+     * Get the best adapter based on current strategy
+     */
+    getBestAdapter(preferredTypes?: StorageType[], requirements?: Partial<StorageCapabilities>): Promise<StorageAdapter | null>;
+    /**
+     * Get multiple adapters sorted by preference
+     */
+    getAdapterChain(count: number, preferredTypes?: StorageType[], requirements?: Partial<StorageCapabilities>): Promise<StorageAdapter[]>;
+    /**
+     * Check if capabilities meet requirements
+     */
+    private meetsRequirements;
+    /**
+     * Compare two adapters based on current strategy
+     */
+    private compareAdapters;
+    /**
+     * Compare adapters by performance
+     */
+    private comparePerformance;
+    /**
+     * Compare adapters by persistence
+     */
+    private comparePersistence;
+    /**
+     * Compare adapters by security
+     */
+    private compareSecurity;
+    /**
+     * Compare adapters by capacity
+     */
+    private compareCapacity;
+    /**
+     * Update strategy
+     */
+    setStrategy(strategy: StorageStrategy): void;
+    /**
+     * Get current strategy
+     */
+    getStrategy(): StorageStrategy;
+}
+//# sourceMappingURL=StorageStrategy.d.ts.map

package/dist/core/StorageStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageStrategy.d.ts","sourceRoot":"","sources":["../../src/core/StorageStrategy.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;GAEG;AACH,qBAAa,eAAe;IAExB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,QAAQ;gBADR,QAAQ,EAAE,eAAe,EACzB,QAAQ,GAAE,eAAmD;IAGvE;;OAEG;IACG,cAAc,CAClB,cAAc,CAAC,EAAE,WAAW,EAAE,EAC9B,YAAY,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAC1C,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAqBjC;;OAEG;IACG,eAAe,CACnB,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,WAAW,EAAE,EAC9B,YAAY,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAC1C,OAAO,CAAC,cAAc,EAAE,CAAC;IAkB5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,eAAe;IAmBvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA0B1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA0B1B;;OAEG;IACH,OAAO,CAAC,eAAe;IA0BvB;;OAEG;IACH,OAAO,CAAC,eAAe;IA+BvB;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAI5C;;OAEG;IACH,WAAW,IAAI,eAAe;CAG/B"}

package/dist/core/StorageStrategy.js

@@ -0,0 +1,199 @@
+/**
+ * Storage strategy implementation for automatic adapter selection
+ */
+import { StorageStrategy } from '@/types';
+/**
+ * Strategy manager for selecting appropriate storage adapters
+ */
+export class StrategyManager {
+    registry;
+    strategy;
+    constructor(registry, strategy = StorageStrategy.PERFORMANCE_FIRST) {
+        this.registry = registry;
+        this.strategy = strategy;
+    }
+    /**
+     * Get the best adapter based on current strategy
+     */
+    async getBestAdapter(preferredTypes, requirements) {
+        const available = await this.registry.getAvailable();
+        // Filter by preferred types if specified
+        let candidates = preferredTypes
+            ? available.filter((adapter) => preferredTypes.includes(adapter.name))
+            : available;
+        // Filter by requirements
+        if (requirements) {
+            candidates = candidates.filter((adapter) => this.meetsRequirements(adapter.capabilities, requirements));
+        }
+        // Sort by strategy
+        candidates.sort((a, b) => this.compareAdapters(a, b));
+        return candidates[0] || null;
+    }
+    /**
+     * Get multiple adapters sorted by preference
+     */
+    async getAdapterChain(count, preferredTypes, requirements) {
+        const available = await this.registry.getAvailable();
+        let candidates = preferredTypes
+            ? available.filter((adapter) => preferredTypes.includes(adapter.name))
+            : available;
+        if (requirements) {
+            candidates = candidates.filter((adapter) => this.meetsRequirements(adapter.capabilities, requirements));
+        }
+        candidates.sort((a, b) => this.compareAdapters(a, b));
+        return candidates.slice(0, count);
+    }
+    /**
+     * Check if capabilities meet requirements
+     */
+    meetsRequirements(capabilities, requirements) {
+        for (const [key, value] of Object.entries(requirements)) {
+            const capKey = key;
+            if (typeof value === 'boolean' && capabilities[capKey] !== value) {
+                return false;
+            }
+            if (capKey === 'maxSize' && typeof value === 'number') {
+                const capSize = capabilities.maxSize;
+                if (capSize !== -1 && capSize < value) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Compare two adapters based on current strategy
+     */
+    compareAdapters(a, b) {
+        switch (this.strategy) {
+            case StorageStrategy.PERFORMANCE_FIRST:
+                return this.comparePerformance(a, b);
+            case StorageStrategy.PERSISTENCE_FIRST:
+                return this.comparePersistence(a, b);
+            case StorageStrategy.SECURITY_FIRST:
+                return this.compareSecurity(a, b);
+            case StorageStrategy.CAPACITY_FIRST:
+                return this.compareCapacity(a, b);
+            default:
+                return 0;
+        }
+    }
+    /**
+     * Compare adapters by performance
+     */
+    comparePerformance(a, b) {
+        // Priority order for performance
+        const performanceOrder = [
+            'memory',
+            'sessionStorage',
+            'localStorage',
+            'cache',
+            'indexedDB',
+            'preferences',
+            'sqlite',
+            'filesystem',
+            'cookies',
+            'secure',
+        ];
+        const aIndex = performanceOrder.indexOf(a.name);
+        const bIndex = performanceOrder.indexOf(b.name);
+        // Prefer synchronous adapters for performance
+        if (a.capabilities.synchronous !== b.capabilities.synchronous) {
+            return a.capabilities.synchronous ? -1 : 1;
+        }
+        return aIndex - bIndex;
+    }
+    /**
+     * Compare adapters by persistence
+     */
+    comparePersistence(a, b) {
+        // Prefer persistent storage
+        if (a.capabilities.persistent !== b.capabilities.persistent) {
+            return a.capabilities.persistent ? -1 : 1;
+        }
+        // Priority order for persistence
+        const persistenceOrder = [
+            'sqlite',
+            'filesystem',
+            'secure',
+            'indexedDB',
+            'preferences',
+            'localStorage',
+            'cache',
+            'cookies',
+            'sessionStorage',
+            'memory',
+        ];
+        const aIndex = persistenceOrder.indexOf(a.name);
+        const bIndex = persistenceOrder.indexOf(b.name);
+        return aIndex - bIndex;
+    }
+    /**
+     * Compare adapters by security
+     */
+    compareSecurity(a, b) {
+        // Prefer encrypted storage
+        if (a.capabilities.encrypted !== b.capabilities.encrypted) {
+            return a.capabilities.encrypted ? -1 : 1;
+        }
+        // Priority order for security
+        const securityOrder = [
+            'secure',
+            'preferences',
+            'sqlite',
+            'indexedDB',
+            'filesystem',
+            'localStorage',
+            'sessionStorage',
+            'cache',
+            'memory',
+            'cookies',
+        ];
+        const aIndex = securityOrder.indexOf(a.name);
+        const bIndex = securityOrder.indexOf(b.name);
+        return aIndex - bIndex;
+    }
+    /**
+     * Compare adapters by capacity
+     */
+    compareCapacity(a, b) {
+        // Compare max sizes (-1 means unlimited)
+        const aSize = a.capabilities.maxSize;
+        const bSize = b.capabilities.maxSize;
+        if (aSize === -1 && bSize !== -1)
+            return -1;
+        if (bSize === -1 && aSize !== -1)
+            return 1;
+        if (aSize !== -1 && bSize !== -1) {
+            return bSize - aSize; // Higher capacity first
+        }
+        // Priority order for capacity
+        const capacityOrder = [
+            'filesystem',
+            'sqlite',
+            'indexedDB',
+            'cache',
+            'preferences',
+            'secure',
+            'localStorage',
+            'memory',
+            'sessionStorage',
+            'cookies',
+        ];
+        const aIndex = capacityOrder.indexOf(a.name);
+        const bIndex = capacityOrder.indexOf(b.name);
+        return aIndex - bIndex;
+    }
+    /**
+     * Update strategy
+     */
+    setStrategy(strategy) {
+        this.strategy = strategy;
+    }
+    /**
+     * Get current strategy
+     */
+    getStrategy() {
+        return this.strategy;
+    }
+}

package/dist/core/Strata.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Strata Storage - Main entry point
+ * Zero-dependency universal storage solution
+ */
+import type { StrataConfig, StorageOptions, StorageType, SizeInfo, ClearOptions, ExportOptions, ImportOptions, SubscriptionCallback, UnsubscribeFunction, QueryCondition, StorageCapabilities } from '@/types';
+/**
+ * Main Strata class - unified storage interface
+ */
+export declare class Strata {
+    private config;
+    private registry;
+    private defaultAdapter?;
+    private adapters;
+    private platform;
+    private encryptionManager?;
+    private compressionManager?;
+    private syncManager?;
+    private ttlManager?;
+    constructor(config?: StrataConfig);
+    /**
+     * Initialize Strata with available adapters
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get a value from storage
+     */
+    get<T = unknown>(key: string, options?: StorageOptions): Promise<T | null>;
+    /**
+     * Set a value in storage
+     */
+    set<T = unknown>(key: string, value: T, options?: StorageOptions): Promise<void>;
+    /**
+     * Remove a value from storage
+     */
+    remove(key: string, options?: StorageOptions): Promise<void>;
+    /**
+     * Check if a key exists
+     */
+    has(key: string, options?: StorageOptions): Promise<boolean>;
+    /**
+     * Clear storage
+     */
+    clear(options?: ClearOptions & StorageOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp, options?: StorageOptions): Promise<string[]>;
+    /**
+     * Get storage size information
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+    /**
+     * Subscribe to storage changes
+     */
+    subscribe(callback: SubscriptionCallback, options?: StorageOptions): UnsubscribeFunction;
+    /**
+     * Query storage (if supported)
+     */
+    query<T = unknown>(condition: QueryCondition, options?: StorageOptions): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    /**
+     * Export storage data
+     */
+    export(options?: ExportOptions): Promise<string>;
+    /**
+     * Import storage data
+     */
+    import(data: string, options?: ImportOptions): Promise<void>;
+    /**
+     * Get available storage types
+     */
+    getAvailableStorageTypes(): StorageType[];
+    /**
+     * Get adapter capabilities
+     */
+    getCapabilities(storage?: StorageType): StorageCapabilities | Record<string, StorageCapabilities>;
+    /**
+     * Generate a secure password for encryption
+     */
+    generatePassword(length?: number): string;
+    /**
+     * Hash data using SHA-256
+     */
+    hash(data: string): Promise<string>;
+    /**
+     * Get TTL (time to live) for a key
+     */
+    getTTL(key: string, options?: StorageOptions): Promise<number | null>;
+    /**
+     * Extend TTL for a key
+     */
+    extendTTL(key: string, extension: number, options?: StorageOptions): Promise<void>;
+    /**
+     * Make a key persistent (remove TTL)
+     */
+    persist(key: string, options?: StorageOptions): Promise<void>;
+    /**
+     * Get items expiring within a time window
+     */
+    getExpiring(timeWindow: number, options?: StorageOptions): Promise<Array<{
+        key: string;
+        expiresIn: number;
+    }>>;
+    /**
+     * Manually trigger TTL cleanup
+     */
+    cleanupExpired(options?: StorageOptions): Promise<number>;
+    /**
+     * Close all adapters
+     */
+    close(): Promise<void>;
+    private normalizeConfig;
+    private detectPlatform;
+    private getDefaultStorages;
+    private registerAdapters;
+    private selectDefaultAdapter;
+    private initializeAdapters;
+    private selectAdapter;
+}
+//# sourceMappingURL=Strata.d.ts.map

package/dist/core/Strata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Strata.d.ts","sourceRoot":"","sources":["../../src/core/Strata.ts"],"names":[],"mappings":"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"}