strata-storage 1.0.0

package/dist/features/compression.js

@@ -0,0 +1,205 @@
+/**
+ * Compression Feature - Pure JavaScript LZ-string implementation
+ * Zero-dependency compression/decompression for storage values
+ */
+import { CompressionError } from '@/utils/errors';
+/**
+ * Compression manager using pure JavaScript LZ-string algorithm
+ */
+export class CompressionManager {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            algorithm: config.algorithm || 'lz',
+            threshold: config.threshold || 1024, // 1KB default threshold
+            level: config.level || 6,
+        };
+    }
+    /**
+     * Compress data using LZ-string algorithm
+     */
+    async compress(data) {
+        try {
+            const jsonStr = JSON.stringify(data);
+            const originalSize = new Blob([jsonStr]).size;
+            // Skip compression if below threshold
+            if (originalSize < this.config.threshold) {
+                return data;
+            }
+            // Compress using LZ algorithm
+            const compressed = this.lzCompress(jsonStr);
+            const compressedSize = new Blob([compressed]).size;
+            // Only use compression if it reduces size
+            if (compressedSize >= originalSize) {
+                return data;
+            }
+            return {
+                data: compressed,
+                algorithm: this.config.algorithm,
+                originalSize,
+                compressedSize,
+            };
+        }
+        catch (error) {
+            throw new CompressionError(`Compression failed: ${error}`);
+        }
+    }
+    /**
+     * Decompress data
+     */
+    async decompress(compressedData) {
+        try {
+            if (!this.isCompressedData(compressedData)) {
+                return compressedData;
+            }
+            const decompressed = this.lzDecompress(compressedData.data);
+            return JSON.parse(decompressed);
+        }
+        catch (error) {
+            throw new CompressionError(`Decompression failed: ${error}`);
+        }
+    }
+    /**
+     * Check if data is compressed
+     */
+    isCompressedData(data) {
+        return (typeof data === 'object' &&
+            data !== null &&
+            'data' in data &&
+            'algorithm' in data &&
+            'originalSize' in data &&
+            'compressedSize' in data);
+    }
+    /**
+     * LZ-string compression implementation
+     */
+    lzCompress(uncompressed) {
+        if (uncompressed == null)
+            return '';
+        const context = new Map();
+        const out = [];
+        let currentChar;
+        let phrase = uncompressed.charAt(0);
+        let code = 256;
+        for (let i = 1; i < uncompressed.length; i++) {
+            currentChar = uncompressed.charAt(i);
+            if (context.has(phrase + currentChar)) {
+                phrase += currentChar;
+            }
+            else {
+                if (phrase.length > 1) {
+                    out.push(String.fromCharCode(context.get(phrase)));
+                }
+                else {
+                    out.push(phrase);
+                }
+                context.set(phrase + currentChar, code);
+                code++;
+                phrase = currentChar;
+            }
+        }
+        if (phrase.length > 1) {
+            out.push(String.fromCharCode(context.get(phrase)));
+        }
+        else {
+            out.push(phrase);
+        }
+        return this.encodeToBase64(out.join(''));
+    }
+    /**
+     * LZ-string decompression implementation
+     */
+    lzDecompress(compressed) {
+        if (compressed == null)
+            return '';
+        if (compressed === '')
+            return '';
+        const decoded = this.decodeFromBase64(compressed);
+        const dictionary = new Map();
+        let currentChar = decoded.charAt(0);
+        let oldPhrase = currentChar;
+        const out = [currentChar];
+        let code = 256;
+        let phrase;
+        for (let i = 1; i < decoded.length; i++) {
+            const currentCode = decoded.charCodeAt(i);
+            if (currentCode < 256) {
+                phrase = decoded.charAt(i);
+            }
+            else {
+                phrase = dictionary.get(currentCode) || oldPhrase + currentChar;
+            }
+            out.push(phrase);
+            currentChar = phrase.charAt(0);
+            dictionary.set(code, oldPhrase + currentChar);
+            code++;
+            oldPhrase = phrase;
+        }
+        return out.join('');
+    }
+    /**
+     * Base64 encoding for compressed data
+     */
+    encodeToBase64(input) {
+        if (typeof btoa !== 'undefined') {
+            // Browser environment
+            return btoa(unescape(encodeURIComponent(input)));
+        }
+        // Pure JS implementation for Node.js or other environments
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        let result = '';
+        let i = 0;
+        while (i < input.length) {
+            const a = input.charCodeAt(i++);
+            const b = i < input.length ? input.charCodeAt(i++) : 0;
+            const c = i < input.length ? input.charCodeAt(i++) : 0;
+            const bitmap = (a << 16) | (b << 8) | c;
+            result += chars.charAt((bitmap >> 18) & 63);
+            result += chars.charAt((bitmap >> 12) & 63);
+            result += i - 2 < input.length ? chars.charAt((bitmap >> 6) & 63) : '=';
+            result += i - 1 < input.length ? chars.charAt(bitmap & 63) : '=';
+        }
+        return result;
+    }
+    /**
+     * Base64 decoding for compressed data
+     */
+    decodeFromBase64(input) {
+        if (typeof atob !== 'undefined') {
+            // Browser environment
+            return decodeURIComponent(escape(atob(input)));
+        }
+        // Pure JS implementation
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        let result = '';
+        let i = 0;
+        input = input.replace(/[^A-Za-z0-9+/]/g, '');
+        while (i < input.length) {
+            const encoded1 = chars.indexOf(input.charAt(i++));
+            const encoded2 = chars.indexOf(input.charAt(i++));
+            const encoded3 = chars.indexOf(input.charAt(i++));
+            const encoded4 = chars.indexOf(input.charAt(i++));
+            const bitmap = (encoded1 << 18) | (encoded2 << 12) | (encoded3 << 6) | encoded4;
+            result += String.fromCharCode((bitmap >> 16) & 255);
+            if (encoded3 !== 64)
+                result += String.fromCharCode((bitmap >> 8) & 255);
+            if (encoded4 !== 64)
+                result += String.fromCharCode(bitmap & 255);
+        }
+        return result;
+    }
+    /**
+     * Get compression ratio
+     */
+    getCompressionRatio(compressedData) {
+        return compressedData.compressedSize / compressedData.originalSize;
+    }
+    /**
+     * Get savings percentage
+     */
+    getSavingsPercentage(compressedData) {
+        return (((compressedData.originalSize - compressedData.compressedSize) /
+            compressedData.originalSize) *
+            100);
+    }
+}

package/dist/features/encryption.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Encryption Feature - Web Crypto API implementation
+ * Zero-dependency encryption/decryption for storage values
+ */
+/**
+ * Encryption configuration
+ */
+export interface EncryptionConfig {
+    algorithm?: 'AES-GCM' | 'AES-CBC';
+    keyLength?: 128 | 192 | 256;
+    iterations?: number;
+    saltLength?: number;
+}
+/**
+ * Encrypted data structure
+ */
+export interface EncryptedData {
+    data: string;
+    salt: string;
+    iv: string;
+    algorithm: string;
+    iterations: number;
+}
+/**
+ * Encryption manager using Web Crypto API
+ */
+export declare class EncryptionManager {
+    private config;
+    private keyCache;
+    constructor(config?: EncryptionConfig);
+    /**
+     * Check if encryption is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Encrypt data
+     */
+    encrypt(data: unknown, password: string): Promise<EncryptedData>;
+    /**
+     * Decrypt data
+     */
+    decrypt<T = unknown>(encryptedData: EncryptedData, password: string): Promise<T>;
+    /**
+     * Derive encryption key from password
+     */
+    private deriveKey;
+    /**
+     * Convert ArrayBuffer to base64
+     */
+    private bufferToBase64;
+    /**
+     * Convert base64 to ArrayBuffer
+     */
+    private base64ToBuffer;
+    /**
+     * Clear key cache
+     */
+    clearCache(): void;
+    /**
+     * Generate a secure random password
+     */
+    generatePassword(length?: number): string;
+    /**
+     * Hash data using SHA-256
+     */
+    hash(data: string): Promise<string>;
+}
+//# sourceMappingURL=encryption.d.ts.map

package/dist/features/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/features/encryption.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,QAAQ,CAAqC;gBAEzC,MAAM,GAAE,gBAAqB;IASzC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAyCtE;;OAEG;IACG,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAiCtF;;OAEG;YACW,SAAS;IA0CvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,gBAAgB,CAAC,MAAM,GAAE,MAAW,GAAG,MAAM;IAc7C;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAU1C"}

package/dist/features/encryption.js

@@ -0,0 +1,172 @@
+/**
+ * Encryption Feature - Web Crypto API implementation
+ * Zero-dependency encryption/decryption for storage values
+ */
+import { EncryptionError } from '@/utils/errors';
+/**
+ * Encryption manager using Web Crypto API
+ */
+export class EncryptionManager {
+    config;
+    keyCache = new Map();
+    constructor(config = {}) {
+        this.config = {
+            algorithm: config.algorithm || 'AES-GCM',
+            keyLength: config.keyLength || 256,
+            iterations: config.iterations || 100000,
+            saltLength: config.saltLength || 16,
+        };
+    }
+    /**
+     * Check if encryption is available
+     */
+    isAvailable() {
+        return typeof window !== 'undefined' && window.crypto && window.crypto.subtle !== undefined;
+    }
+    /**
+     * Encrypt data
+     */
+    async encrypt(data, password) {
+        if (!this.isAvailable()) {
+            throw new EncryptionError('Web Crypto API not available');
+        }
+        try {
+            // Convert data to string
+            const dataStr = JSON.stringify(data);
+            const encoder = new TextEncoder();
+            const dataBuffer = encoder.encode(dataStr);
+            // Generate salt and IV
+            const salt = crypto.getRandomValues(new Uint8Array(this.config.saltLength));
+            const iv = crypto.getRandomValues(new Uint8Array(12)); // 12 bytes for GCM
+            // Derive key from password
+            const key = await this.deriveKey(password, salt);
+            // Encrypt data
+            const encryptedBuffer = await crypto.subtle.encrypt({
+                name: this.config.algorithm,
+                iv: iv,
+            }, key, dataBuffer);
+            // Convert to base64 for storage
+            return {
+                data: this.bufferToBase64(encryptedBuffer),
+                salt: this.bufferToBase64(salt),
+                iv: this.bufferToBase64(iv),
+                algorithm: this.config.algorithm,
+                iterations: this.config.iterations,
+            };
+        }
+        catch (error) {
+            throw new EncryptionError(`Encryption failed: ${error}`);
+        }
+    }
+    /**
+     * Decrypt data
+     */
+    async decrypt(encryptedData, password) {
+        if (!this.isAvailable()) {
+            throw new EncryptionError('Web Crypto API not available');
+        }
+        try {
+            // Convert from base64
+            const dataBuffer = this.base64ToBuffer(encryptedData.data);
+            const salt = this.base64ToBuffer(encryptedData.salt);
+            const iv = this.base64ToBuffer(encryptedData.iv);
+            // Derive key from password
+            const key = await this.deriveKey(password, new Uint8Array(salt), encryptedData.iterations);
+            // Decrypt data
+            const decryptedBuffer = await crypto.subtle.decrypt({
+                name: encryptedData.algorithm,
+                iv: iv,
+            }, key, dataBuffer);
+            // Convert back to original data
+            const decoder = new TextDecoder();
+            const decryptedStr = decoder.decode(decryptedBuffer);
+            return JSON.parse(decryptedStr);
+        }
+        catch (error) {
+            throw new EncryptionError(`Decryption failed: ${error}`);
+        }
+    }
+    /**
+     * Derive encryption key from password
+     */
+    async deriveKey(password, salt, iterations = this.config.iterations) {
+        // Check cache
+        const cacheKey = `${password}-${this.bufferToBase64(salt)}-${iterations}`;
+        if (this.keyCache.has(cacheKey)) {
+            return this.keyCache.get(cacheKey);
+        }
+        // Import password as key material
+        const encoder = new TextEncoder();
+        const passwordBuffer = encoder.encode(password);
+        const keyMaterial = await crypto.subtle.importKey('raw', passwordBuffer, 'PBKDF2', false, [
+            'deriveBits',
+            'deriveKey',
+        ]);
+        // Derive key using PBKDF2
+        const key = await crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt: salt,
+            iterations: iterations,
+            hash: 'SHA-256',
+        }, keyMaterial, {
+            name: this.config.algorithm,
+            length: this.config.keyLength,
+        }, false, ['encrypt', 'decrypt']);
+        // Cache the key
+        this.keyCache.set(cacheKey, key);
+        return key;
+    }
+    /**
+     * Convert ArrayBuffer to base64
+     */
+    bufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Convert base64 to ArrayBuffer
+     */
+    base64ToBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    /**
+     * Clear key cache
+     */
+    clearCache() {
+        this.keyCache.clear();
+    }
+    /**
+     * Generate a secure random password
+     */
+    generatePassword(length = 32) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?';
+        const array = new Uint8Array(length);
+        crypto.getRandomValues(array);
+        let password = '';
+        for (let i = 0; i < length; i++) {
+            password += chars[array[i] % chars.length];
+        }
+        return password;
+    }
+    /**
+     * Hash data using SHA-256
+     */
+    async hash(data) {
+        if (!this.isAvailable()) {
+            throw new EncryptionError('Web Crypto API not available');
+        }
+        const encoder = new TextEncoder();
+        const dataBuffer = encoder.encode(data);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
+        return this.bufferToBase64(hashBuffer);
+    }
+}

package/dist/features/migration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Migration utilities for storage upgrades
+ */
+import type { StorageAdapter } from '@/types';
+export interface Migration {
+    version: number;
+    up: (adapter: StorageAdapter) => Promise<void>;
+    down?: (adapter: StorageAdapter) => Promise<void>;
+}
+export declare class MigrationManager {
+    private migrations;
+    register(migration: Migration): void;
+    migrate(adapter: StorageAdapter, targetVersion: number): Promise<void>;
+    private getCurrentVersion;
+    private setVersion;
+}
+//# sourceMappingURL=migration.d.ts.map

package/dist/features/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../src/features/migration.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,UAAU,CAAmB;IAErC,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAK9B,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YA0B9D,iBAAiB;YAKjB,UAAU;CAOzB"}

package/dist/features/migration.js

@@ -0,0 +1,43 @@
+/**
+ * Migration utilities for storage upgrades
+ */
+export class MigrationManager {
+    migrations = [];
+    register(migration) {
+        this.migrations.push(migration);
+        this.migrations.sort((a, b) => a.version - b.version);
+    }
+    async migrate(adapter, targetVersion) {
+        const currentVersion = await this.getCurrentVersion(adapter);
+        if (currentVersion === targetVersion)
+            return;
+        const migrationsToRun = this.migrations.filter((m) => currentVersion < targetVersion
+            ? m.version > currentVersion && m.version <= targetVersion
+            : m.version <= currentVersion && m.version > targetVersion);
+        if (currentVersion < targetVersion) {
+            for (const migration of migrationsToRun) {
+                await migration.up(adapter);
+                await this.setVersion(adapter, migration.version);
+            }
+        }
+        else {
+            for (const migration of migrationsToRun.reverse()) {
+                if (migration.down) {
+                    await migration.down(adapter);
+                }
+                await this.setVersion(adapter, migration.version - 1);
+            }
+        }
+    }
+    async getCurrentVersion(adapter) {
+        const versionData = await adapter.get('__strata_version__');
+        return versionData?.value || 0;
+    }
+    async setVersion(adapter, version) {
+        await adapter.set('__strata_version__', {
+            value: version,
+            created: Date.now(),
+            updated: Date.now(),
+        });
+    }
+}

package/dist/features/query.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Query Engine Feature
+ * Zero-dependency implementation of MongoDB-like query operators
+ */
+import type { QueryCondition } from '@/types';
+/**
+ * Query engine for advanced data filtering
+ */
+export declare class QueryEngine {
+    /**
+     * Check if a value matches a query condition
+     */
+    matches(value: unknown, condition: QueryCondition): boolean;
+    /**
+     * Check if object has query operators
+     */
+    private hasOperators;
+    /**
+     * Match value against operators
+     */
+    private matchesOperators;
+    /**
+     * Match single operator
+     */
+    private matchesOperator;
+    /**
+     * Match object against condition
+     */
+    private matchesObject;
+    /**
+     * Get nested value from object using dot notation
+     */
+    private getNestedValue;
+    /**
+     * Check equality with proper type handling
+     */
+    private equals;
+    /**
+     * Compare values
+     */
+    private compare;
+    /**
+     * Match regex pattern
+     */
+    private matchesRegex;
+    /**
+     * Get JavaScript type of value
+     */
+    private getType;
+    /**
+     * Handle null/undefined matching
+     */
+    private matchesNull;
+    /**
+     * Sort array of items by multiple fields
+     */
+    sort<T>(items: T[], sortBy: Record<string, 1 | -1>): T[];
+    /**
+     * Project/transform objects based on projection spec
+     */
+    project<T>(item: T, projection: Record<string, 0 | 1 | boolean>): Partial<T>;
+    /**
+     * Set nested value in object using dot notation
+     */
+    private setNestedValue;
+    /**
+     * Delete nested value from object using dot notation
+     */
+    private deleteNestedValue;
+}
+/**
+ * Create a query engine instance
+ */
+export declare function createQueryEngine(): QueryEngine;
+//# sourceMappingURL=query.d.ts.map

package/dist/features/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/features/query.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,SAAS,CAAC;AAE9D;;GAEG;AACH,qBAAa,WAAW;IACtB;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,GAAG,OAAO;IAwB3D;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IASxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqDvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAkBrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAmBtB;;OAEG;IACH,OAAO,CAAC,MAAM;IA+Bd;;OAEG;IACH,OAAO,CAAC,OAAO;IAyBf;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,OAAO;IASf;;OAEG;IACH,OAAO,CAAC,WAAW;IAcnB;;OAEG;IACH,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;IAoBxD;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA2B5E;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAc1B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C"}