strata-storage 1.0.0

package/dist/adapters/web/CacheAdapter.js

@@ -0,0 +1,291 @@
+/**
+ * Cache Adapter - Service Worker Cache API implementation
+ * Provides network-aware storage for offline support
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { getObjectSize } from '@/utils';
+import { StorageError, QuotaExceededError, NotSupportedError } from '@/utils/errors';
+/**
+ * Cache API adapter for Service Worker environments
+ */
+export class CacheAdapter extends BaseAdapter {
+    name = 'cache';
+    capabilities = {
+        persistent: true,
+        synchronous: false,
+        observable: false, // No native change events
+        transactional: false,
+        queryable: true,
+        maxSize: -1, // Browser dependent, typically GBs
+        binary: true, // Supports binary data via Response
+        encrypted: false,
+        crossTab: true, // Shared across tabs via Service Worker
+    };
+    cacheName;
+    baseUrl;
+    cache;
+    constructor(cacheName = 'strata-storage-v1', baseUrl = 'https://strata.local/') {
+        super();
+        this.cacheName = cacheName;
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Check if Cache API is available
+     */
+    async isAvailable() {
+        return typeof window !== 'undefined' && 'caches' in window && typeof caches.open === 'function';
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize(config) {
+        if (config?.cacheName)
+            this.cacheName = config.cacheName;
+        if (config?.baseUrl)
+            this.baseUrl = config.baseUrl;
+        await this.openCache();
+        this.startTTLCleanup();
+    }
+    /**
+     * Open cache
+     */
+    async openCache() {
+        if (this.cache)
+            return this.cache;
+        if (!('caches' in window)) {
+            throw new NotSupportedError('Cache API not available');
+        }
+        this.cache = await caches.open(this.cacheName);
+        return this.cache;
+    }
+    /**
+     * Create URL for key
+     */
+    keyToUrl(key) {
+        return new URL(encodeURIComponent(key), this.baseUrl).href;
+    }
+    /**
+     * Extract key from URL
+     */
+    urlToKey(url) {
+        const urlObj = new URL(url);
+        const pathname = urlObj.pathname;
+        const lastSegment = pathname.split('/').pop() || '';
+        return decodeURIComponent(lastSegment);
+    }
+    /**
+     * Get a value from cache
+     */
+    async get(key) {
+        const cache = await this.openCache();
+        const url = this.keyToUrl(key);
+        try {
+            const response = await cache.match(url);
+            if (!response)
+                return null;
+            const data = (await response.json());
+            // Check TTL
+            if (this.isExpired(data)) {
+                await this.remove(key);
+                return null;
+            }
+            return data;
+        }
+        catch (error) {
+            console.error(`Failed to get key ${key} from cache:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value) {
+        const cache = await this.openCache();
+        const url = this.keyToUrl(key);
+        const oldValue = await this.get(key);
+        try {
+            // Create Response with the data
+            const response = new Response(JSON.stringify(value), {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Strata-Created': value.created.toString(),
+                    'X-Strata-Updated': value.updated.toString(),
+                    'X-Strata-Expires': value.expires?.toString() || '',
+                },
+            });
+            await cache.put(url, response);
+            this.emitChange(key, oldValue?.value, value.value, 'local');
+        }
+        catch (error) {
+            if (this.isQuotaError(error)) {
+                throw new QuotaExceededError('Cache quota exceeded', { key, size: getObjectSize(value) });
+            }
+            throw new StorageError(`Failed to set key ${key} in cache: ${error}`);
+        }
+    }
+    /**
+     * Remove a value from cache
+     */
+    async remove(key) {
+        const cache = await this.openCache();
+        const url = this.keyToUrl(key);
+        const oldValue = await this.get(key);
+        const deleted = await cache.delete(url);
+        if (deleted && oldValue) {
+            this.emitChange(key, oldValue.value, undefined, 'local');
+        }
+    }
+    /**
+     * Clear cache
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            // Delete and recreate cache
+            await caches.delete(this.cacheName);
+            this.cache = await caches.open(this.cacheName);
+            this.emitChange('*', undefined, undefined, 'local');
+            return;
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        const cache = await this.openCache();
+        const requests = await cache.keys();
+        const keys = [];
+        for (const request of requests) {
+            const key = this.urlToKey(request.url);
+            // Check if not expired
+            const value = await this.get(key);
+            if (value) {
+                keys.push(key);
+            }
+        }
+        return this.filterKeys(keys, pattern);
+    }
+    /**
+     * Query cache with conditions
+     */
+    async query(condition) {
+        const cache = await this.openCache();
+        const requests = await cache.keys();
+        const results = [];
+        for (const request of requests) {
+            const key = this.urlToKey(request.url);
+            const value = await this.get(key);
+            if (value && this.queryEngine.matches(value.value, condition)) {
+                results.push({ key, value: value.value });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        const cache = await this.openCache();
+        const requests = await cache.keys();
+        let total = 0;
+        let count = 0;
+        let keySize = 0;
+        let valueSize = 0;
+        let metadataSize = 0;
+        for (const request of requests) {
+            const response = await cache.match(request);
+            if (response) {
+                count++;
+                const key = this.urlToKey(request.url);
+                const blob = await response.blob();
+                const contentSize = blob.size;
+                total += key.length * 2 + contentSize;
+                if (detailed) {
+                    keySize += key.length * 2;
+                    valueSize += contentSize;
+                    // Headers contribute to metadata
+                    const headers = response.headers;
+                    headers.forEach((value, key) => {
+                        metadataSize += (key.length + value.length) * 2;
+                    });
+                }
+            }
+        }
+        const result = { total, count };
+        if (detailed) {
+            result.detailed = {
+                keys: keySize,
+                values: valueSize,
+                metadata: metadataSize,
+            };
+        }
+        return result;
+    }
+    /**
+     * Store binary data
+     */
+    async setBinary(key, data, metadata) {
+        const cache = await this.openCache();
+        const url = this.keyToUrl(key);
+        const now = Date.now();
+        // Create storage value for metadata
+        const storageMetadata = {
+            value: metadata || {},
+            created: now,
+            updated: now,
+            metadata: { binary: true, size: data instanceof ArrayBuffer ? data.byteLength : data.size },
+        };
+        // Create Response with binary data
+        const response = new Response(data, {
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'X-Strata-Metadata': JSON.stringify(storageMetadata),
+            },
+        });
+        await cache.put(url, response);
+        this.emitChange(key, undefined, metadata || {}, 'local');
+    }
+    /**
+     * Get binary data
+     */
+    async getBinary(key) {
+        const cache = await this.openCache();
+        const url = this.keyToUrl(key);
+        try {
+            const response = await cache.match(url);
+            if (!response)
+                return null;
+            const metadataHeader = response.headers.get('X-Strata-Metadata');
+            const metadata = metadataHeader ? JSON.parse(metadataHeader) : null;
+            // Check if it's binary data
+            if (response.headers.get('Content-Type') !== 'application/octet-stream') {
+                return null;
+            }
+            const data = await response.arrayBuffer();
+            return { data, metadata: metadata?.value };
+        }
+        catch (error) {
+            console.error(`Failed to get binary data for key ${key}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Close the adapter
+     */
+    async close() {
+        this.cache = undefined;
+        if (super.close) {
+            await super.close();
+        }
+    }
+    /**
+     * Check if error is quota exceeded
+     */
+    isQuotaError(error) {
+        if (error instanceof Error || error instanceof DOMException) {
+            return error.name === 'QuotaExceededError' || error.message.toLowerCase().includes('quota');
+        }
+        return false;
+    }
+}

package/dist/adapters/web/CookieAdapter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Cookie Adapter - Browser cookie implementation
+ * Provides limited storage with 4KB per cookie limit
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import type { StorageType, StorageCapabilities, StorageValue, ClearOptions, SizeInfo } from '@/types';
+/**
+ * Cookie options
+ */
+interface CookieOptions {
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+    maxAge?: number;
+}
+/**
+ * Browser cookie adapter
+ */
+export declare class CookieAdapter extends BaseAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    private prefix;
+    private cookieOptions;
+    private maxCookieSize;
+    constructor(prefix?: string, options?: CookieOptions);
+    /**
+     * Check if cookies are available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Initialize the adapter
+     */
+    initialize(config?: CookieOptions): Promise<void>;
+    /**
+     * Get a value from cookies
+     */
+    get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    /**
+     * Set a value in cookies
+     */
+    set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from cookies
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear cookies
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Get storage size
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+    /**
+     * Get a cookie value
+     */
+    private getCookie;
+    /**
+     * Set a cookie
+     */
+    private setCookie;
+    /**
+     * Delete a cookie
+     */
+    private deleteCookie;
+    /**
+     * Get all cookies as key-value pairs
+     */
+    private getAllCookies;
+}
+export {};
+//# sourceMappingURL=CookieAdapter.d.ts.map

package/dist/adapters/web/CookieAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CookieAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/web/CookieAdapter.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;AAGjB;;GAEG;AACH,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,WAAW;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAa;IACvC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAUxC;IAEF,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,aAAa,CAAQ;gBAEjB,MAAM,SAAY,EAAE,OAAO,GAAE,aAAkB;IAS3D;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAiBrC;;OAEG;IACG,UAAU,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvD;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAuBpE;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC1E;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWxC;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlD;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmBxD;;OAEG;IACG,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAmCjD;;OAEG;IACH,OAAO,CAAC,SAAS;IAgBjB;;OAEG;IACH,OAAO,CAAC,SAAS;IA4BjB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,aAAa;CAmBtB"}

package/dist/adapters/web/CookieAdapter.js

@@ -0,0 +1,260 @@
+/**
+ * Cookie Adapter - Browser cookie implementation
+ * Provides limited storage with 4KB per cookie limit
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { StorageError, QuotaExceededError } from '@/utils/errors';
+/**
+ * Browser cookie adapter
+ */
+export class CookieAdapter extends BaseAdapter {
+    name = 'cookies';
+    capabilities = {
+        persistent: true,
+        synchronous: false,
+        observable: false, // No native change events
+        transactional: false,
+        queryable: true,
+        maxSize: 4096, // 4KB per cookie
+        binary: false,
+        encrypted: false,
+        crossTab: true, // Cookies are shared across tabs
+    };
+    prefix;
+    cookieOptions;
+    maxCookieSize = 4096; // 4KB limit per cookie
+    constructor(prefix = 'strata_', options = {}) {
+        super();
+        this.prefix = prefix;
+        this.cookieOptions = {
+            path: '/',
+            ...options,
+        };
+    }
+    /**
+     * Check if cookies are available
+     */
+    async isAvailable() {
+        if (typeof window === 'undefined' || !navigator.cookieEnabled) {
+            return false;
+        }
+        // Test if we can actually set cookies
+        try {
+            const testKey = `${this.prefix}test`;
+            this.setCookie(testKey, 'test', { maxAge: 1 });
+            const result = this.getCookie(testKey) === 'test';
+            this.deleteCookie(testKey);
+            return result;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize(config) {
+        if (config) {
+            this.cookieOptions = { ...this.cookieOptions, ...config };
+        }
+        this.startTTLCleanup();
+    }
+    /**
+     * Get a value from cookies
+     */
+    async get(key) {
+        const cookieKey = this.prefix + key;
+        const value = this.getCookie(cookieKey);
+        if (!value)
+            return null;
+        try {
+            const decoded = decodeURIComponent(value);
+            const parsed = JSON.parse(decoded);
+            // Check TTL
+            if (this.isExpired(parsed)) {
+                await this.remove(key);
+                return null;
+            }
+            return parsed;
+        }
+        catch (error) {
+            console.error(`Failed to parse cookie ${key}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in cookies
+     */
+    async set(key, value) {
+        const cookieKey = this.prefix + key;
+        const oldValue = await this.get(key);
+        try {
+            const serialized = JSON.stringify(value);
+            const encoded = encodeURIComponent(serialized);
+            // Check size limit
+            if (encoded.length > this.maxCookieSize) {
+                throw new QuotaExceededError(`Cookie size ${encoded.length} exceeds limit ${this.maxCookieSize}`, { key, size: encoded.length });
+            }
+            // Set cookie with options
+            const options = { ...this.cookieOptions };
+            // Handle TTL
+            if (value.expires) {
+                const maxAge = Math.floor((value.expires - Date.now()) / 1000);
+                if (maxAge > 0) {
+                    options.maxAge = maxAge;
+                }
+            }
+            this.setCookie(cookieKey, encoded, options);
+            this.emitChange(key, oldValue?.value, value.value, 'local');
+        }
+        catch (error) {
+            if (error instanceof QuotaExceededError) {
+                throw error;
+            }
+            throw new StorageError(`Failed to set cookie ${key}: ${error}`);
+        }
+    }
+    /**
+     * Remove a value from cookies
+     */
+    async remove(key) {
+        const oldValue = await this.get(key);
+        const cookieKey = this.prefix + key;
+        this.deleteCookie(cookieKey);
+        if (oldValue) {
+            this.emitChange(key, oldValue.value, undefined, 'local');
+        }
+    }
+    /**
+     * Clear cookies
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            // Clear all cookies with our prefix
+            const cookies = this.getAllCookies();
+            for (const [cookieKey] of cookies) {
+                if (cookieKey.startsWith(this.prefix)) {
+                    this.deleteCookie(cookieKey);
+                }
+            }
+            this.emitChange('*', undefined, undefined, 'local');
+            return;
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        const cookies = this.getAllCookies();
+        const keys = [];
+        for (const [cookieKey] of cookies) {
+            if (cookieKey.startsWith(this.prefix)) {
+                const key = cookieKey.substring(this.prefix.length);
+                // Check if not expired
+                const value = await this.get(key);
+                if (value) {
+                    keys.push(key);
+                }
+            }
+        }
+        return this.filterKeys(keys, pattern);
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        const cookies = this.getAllCookies();
+        let total = 0;
+        let count = 0;
+        let keySize = 0;
+        let valueSize = 0;
+        for (const [cookieKey, cookieValue] of cookies) {
+            if (cookieKey.startsWith(this.prefix)) {
+                count++;
+                const itemSize = (cookieKey.length + cookieValue.length) * 2; // UTF-16
+                total += itemSize;
+                if (detailed) {
+                    keySize += cookieKey.length * 2;
+                    valueSize += cookieValue.length * 2;
+                }
+            }
+        }
+        const result = { total, count };
+        if (detailed) {
+            result.detailed = {
+                keys: keySize,
+                values: valueSize,
+                metadata: 0,
+            };
+        }
+        return result;
+    }
+    // Cookie manipulation helpers
+    /**
+     * Get a cookie value
+     */
+    getCookie(name) {
+        if (typeof document === 'undefined')
+            return null;
+        const nameEQ = name + '=';
+        const cookies = document.cookie.split(';');
+        for (const cookie of cookies) {
+            const trimmed = cookie.trim();
+            if (trimmed.indexOf(nameEQ) === 0) {
+                return trimmed.substring(nameEQ.length);
+            }
+        }
+        return null;
+    }
+    /**
+     * Set a cookie
+     */
+    setCookie(name, value, options = {}) {
+        if (typeof document === 'undefined')
+            return;
+        let cookie = `${name}=${value}`;
+        if (options.maxAge !== undefined) {
+            cookie += `; max-age=${options.maxAge}`;
+        }
+        if (options.domain) {
+            cookie += `; domain=${options.domain}`;
+        }
+        if (options.path) {
+            cookie += `; path=${options.path}`;
+        }
+        if (options.secure) {
+            cookie += '; secure';
+        }
+        if (options.sameSite) {
+            cookie += `; samesite=${options.sameSite}`;
+        }
+        document.cookie = cookie;
+    }
+    /**
+     * Delete a cookie
+     */
+    deleteCookie(name) {
+        this.setCookie(name, '', { ...this.cookieOptions, maxAge: 0 });
+    }
+    /**
+     * Get all cookies as key-value pairs
+     */
+    getAllCookies() {
+        if (typeof document === 'undefined')
+            return [];
+        const cookies = [];
+        const cookieStrings = document.cookie.split(';');
+        for (const cookie of cookieStrings) {
+            const trimmed = cookie.trim();
+            const eqIndex = trimmed.indexOf('=');
+            if (eqIndex > 0) {
+                const name = trimmed.substring(0, eqIndex);
+                const value = trimmed.substring(eqIndex + 1);
+                cookies.push([name, value]);
+            }
+        }
+        return cookies;
+    }
+}

package/dist/adapters/web/IndexedDBAdapter.d.ts

@@ -0,0 +1,78 @@
+/**
+ * IndexedDB Adapter - Browser IndexedDB implementation
+ * Provides large-scale persistent storage with advanced features
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import type { StorageType, StorageCapabilities, StorageValue, ClearOptions, SizeInfo, QueryCondition, Transaction } from '@/types';
+/**
+ * Browser IndexedDB adapter
+ */
+export declare class IndexedDBAdapter extends BaseAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    private dbName;
+    private storeName;
+    private version;
+    private db?;
+    constructor(dbName?: string, storeName?: string, version?: number);
+    /**
+     * Check if IndexedDB is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Initialize the adapter
+     */
+    initialize(config?: {
+        dbName?: string;
+        storeName?: string;
+        version?: number;
+    }): Promise<void>;
+    /**
+     * Open IndexedDB database
+     */
+    private openDatabase;
+    /**
+     * Get a value from IndexedDB
+     */
+    get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    /**
+     * Set a value in IndexedDB
+     */
+    set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from IndexedDB
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear IndexedDB
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Query IndexedDB with conditions
+     */
+    query<T = unknown>(condition: QueryCondition): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    /**
+     * Get storage size
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+    /**
+     * Begin a transaction
+     */
+    transaction(): Promise<Transaction>;
+    /**
+     * Close the adapter
+     */
+    close(): Promise<void>;
+    /**
+     * Check if error is quota exceeded
+     */
+    private isQuotaError;
+}
+//# sourceMappingURL=IndexedDBAdapter.d.ts.map