strata-storage 1.0.0

package/dist/utils/errors.js

@@ -0,0 +1,153 @@
+/**
+ * Custom error classes for Strata Storage
+ */
+/**
+ * Base error class for all Strata errors
+ */
+export class StrataError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'StrataError';
+        this.code = code;
+        this.details = details;
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * Error thrown when storage quota is exceeded
+ */
+export class QuotaExceededError extends StrataError {
+    constructor(message = 'Storage quota exceeded', details) {
+        super(message, 'QUOTA_EXCEEDED', details);
+        this.name = 'QuotaExceededError';
+    }
+}
+/**
+ * Error thrown when adapter is not available
+ */
+export class AdapterNotAvailableError extends StrataError {
+    constructor(adapterName, details) {
+        super(`Storage adapter '${adapterName}' is not available`, 'ADAPTER_NOT_AVAILABLE', details);
+        this.name = 'AdapterNotAvailableError';
+    }
+}
+/**
+ * Error thrown when operation is not supported
+ */
+export class NotSupportedError extends StrataError {
+    constructor(operation, adapterName, details) {
+        const message = adapterName
+            ? `Operation '${operation}' is not supported by ${adapterName} adapter`
+            : `Operation '${operation}' is not supported`;
+        super(message, 'NOT_SUPPORTED', details);
+        this.name = 'NotSupportedError';
+    }
+}
+/**
+ * Error thrown when encryption fails
+ */
+export class EncryptionError extends StrataError {
+    constructor(message = 'Encryption operation failed', details) {
+        super(message, 'ENCRYPTION_ERROR', details);
+        this.name = 'EncryptionError';
+    }
+}
+/**
+ * Error thrown when compression fails
+ */
+export class CompressionError extends StrataError {
+    constructor(message = 'Compression operation failed', details) {
+        super(message, 'COMPRESSION_ERROR', details);
+        this.name = 'CompressionError';
+    }
+}
+/**
+ * Error thrown when serialization fails
+ */
+export class SerializationError extends StrataError {
+    constructor(message = 'Serialization failed', details) {
+        super(message, 'SERIALIZATION_ERROR', details);
+        this.name = 'SerializationError';
+    }
+}
+/**
+ * Error thrown when validation fails
+ */
+export class ValidationError extends StrataError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', details);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Error thrown when transaction fails
+ */
+export class TransactionError extends StrataError {
+    constructor(message = 'Transaction failed', details) {
+        super(message, 'TRANSACTION_ERROR', details);
+        this.name = 'TransactionError';
+    }
+}
+/**
+ * Error thrown when migration fails
+ */
+export class MigrationError extends StrataError {
+    constructor(message, details) {
+        super(message, 'MIGRATION_ERROR', details);
+        this.name = 'MigrationError';
+    }
+}
+/**
+ * Error thrown when sync operation fails
+ */
+export class SyncError extends StrataError {
+    constructor(message = 'Sync operation failed', details) {
+        super(message, 'SYNC_ERROR', details);
+        this.name = 'SyncError';
+    }
+}
+/**
+ * Check if error is a Strata error
+ */
+export function isStrataError(error) {
+    return error instanceof StrataError;
+}
+/**
+ * General storage error
+ */
+export class StorageError extends StrataError {
+    constructor(message, details) {
+        super(message, 'STORAGE_ERROR', details);
+        this.name = 'StorageError';
+    }
+}
+/**
+ * Error thrown when a key is not found
+ */
+export class NotFoundError extends StrataError {
+    constructor(key, details) {
+        super(`Key '${key}' not found`, 'NOT_FOUND', details);
+        this.name = 'NotFoundError';
+    }
+}
+/**
+ * Check if error is a quota exceeded error
+ */
+export function isQuotaError(error) {
+    if (error instanceof QuotaExceededError)
+        return true;
+    // Check for native quota errors
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        return (message.includes('quota') ||
+            message.includes('storage exhausted') ||
+            error.name === 'QuotaExceededError' ||
+            error.name === 'NS_ERROR_DOM_QUOTA_REACHED');
+    }
+    return false;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Utility functions for Strata Storage
+ * Zero dependencies - all utilities implemented from scratch
+ */
+/**
+ * Check if code is running in a browser environment
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Check if code is running in Node.js
+ */
+export declare function isNode(): boolean;
+/**
+ * Check if code is running in a Web Worker
+ */
+export declare function isWebWorker(): boolean;
+/**
+ * Check if code is running in Capacitor
+ */
+export declare function isCapacitor(): boolean;
+/**
+ * Deep clone an object (no dependencies!)
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Deep merge objects
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Check if value is a plain object
+ */
+export declare function isObject(item: unknown): item is Record<string, unknown>;
+/**
+ * Generate a unique ID
+ */
+export declare function generateId(): string;
+/**
+ * Simple glob pattern matching
+ */
+export declare function matchGlob(pattern: string, str: string): boolean;
+/**
+ * Format bytes to human readable
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;
+/**
+ * Parse size string to bytes
+ */
+export declare function parseSize(size: string | number): number;
+/**
+ * Debounce function
+ */
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Throttle function
+ */
+export declare function throttle<T extends (...args: unknown[]) => unknown>(func: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * Promise with timeout
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string): Promise<T>;
+/**
+ * Retry with exponential backoff
+ */
+export declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    factor?: number;
+}): Promise<T>;
+/**
+ * Sleep for specified milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Create a deferred promise
+ */
+export declare function createDeferred<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+};
+/**
+ * Serialize value to JSON with support for special types
+ */
+export declare function serialize(value: unknown): string;
+/**
+ * Deserialize JSON with support for special types
+ */
+export declare function deserialize(json: string): unknown;
+/**
+ * Calculate object size in bytes (rough estimate)
+ */
+export declare function getObjectSize(obj: unknown): number;
+/**
+ * Create a simple event emitter
+ */
+export declare class EventEmitter {
+    private events;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+    emit(event: string, ...args: unknown[]): void;
+    once(event: string, handler: (...args: unknown[]) => void): void;
+    removeAllListeners(event?: string): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

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

package/dist/utils/index.js

@@ -0,0 +1,329 @@
+/**
+ * Utility functions for Strata Storage
+ * Zero dependencies - all utilities implemented from scratch
+ */
+/**
+ * Check if code is running in a browser environment
+ */
+export function isBrowser() {
+    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+}
+/**
+ * Check if code is running in Node.js
+ */
+export function isNode() {
+    return (typeof process !== 'undefined' &&
+        process.versions !== undefined &&
+        process.versions.node !== undefined);
+}
+/**
+ * Check if code is running in a Web Worker
+ */
+export function isWebWorker() {
+    return (typeof self !== 'undefined' &&
+        typeof self.importScripts === 'function');
+}
+/**
+ * Check if code is running in Capacitor
+ */
+export function isCapacitor() {
+    return typeof window?.Capacitor !== 'undefined';
+}
+/**
+ * Deep clone an object (no dependencies!)
+ */
+export function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (obj instanceof Date)
+        return new Date(obj.getTime());
+    if (obj instanceof Array)
+        return obj.map((item) => deepClone(item));
+    if (obj instanceof RegExp)
+        return new RegExp(obj.source, obj.flags);
+    const clonedObj = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = deepClone(obj[key]);
+        }
+    }
+    return clonedObj;
+}
+/**
+ * Deep merge objects
+ */
+export function deepMerge(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                deepMerge(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return deepMerge(target, ...sources);
+}
+/**
+ * Check if value is a plain object
+ */
+export function isObject(item) {
+    return item !== null && typeof item === 'object' && item.constructor === Object;
+}
+/**
+ * Generate a unique ID
+ */
+export function generateId() {
+    const timestamp = Date.now().toString(36);
+    const randomPart = Math.random().toString(36).substring(2, 9);
+    return `${timestamp}-${randomPart}`;
+}
+/**
+ * Simple glob pattern matching
+ */
+export function matchGlob(pattern, str) {
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${regexPattern}$`).test(str);
+}
+/**
+ * Format bytes to human readable
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+/**
+ * Parse size string to bytes
+ */
+export function parseSize(size) {
+    if (typeof size === 'number')
+        return size;
+    const units = {
+        b: 1,
+        byte: 1,
+        bytes: 1,
+        kb: 1024,
+        mb: 1024 * 1024,
+        gb: 1024 * 1024 * 1024,
+        tb: 1024 * 1024 * 1024 * 1024,
+    };
+    const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*([a-z]+)?$/);
+    if (!match)
+        throw new Error(`Invalid size format: ${size}`);
+    const [, num, unit = 'b'] = match;
+    const multiplier = units[unit] || 1;
+    return parseFloat(num) * multiplier;
+}
+/**
+ * Debounce function
+ */
+export function debounce(func, wait) {
+    let timeout = null;
+    return function executedFunction(...args) {
+        const later = () => {
+            timeout = null;
+            func(...args);
+        };
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+    };
+}
+/**
+ * Throttle function
+ */
+export function throttle(func, limit) {
+    let inThrottle = false;
+    return function executedFunction(...args) {
+        if (!inThrottle) {
+            func(...args);
+            inThrottle = true;
+            setTimeout(() => (inThrottle = false), limit);
+        }
+    };
+}
+/**
+ * Promise with timeout
+ */
+export function withTimeout(promise, timeoutMs, errorMessage = 'Operation timed out') {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(errorMessage));
+        }, timeoutMs);
+        promise
+            .then(resolve)
+            .catch(reject)
+            .finally(() => clearTimeout(timer));
+    });
+}
+/**
+ * Retry with exponential backoff
+ */
+export async function retry(fn, options = {}) {
+    const { maxRetries = 3, initialDelay = 100, maxDelay = 10000, factor = 2 } = options;
+    let lastError;
+    let delay = initialDelay;
+    for (let i = 0; i <= maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (i === maxRetries)
+                break;
+            await sleep(delay);
+            delay = Math.min(delay * factor, maxDelay);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Sleep for specified milliseconds
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Create a deferred promise
+ */
+export function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+/**
+ * Serialize value to JSON with support for special types
+ */
+export function serialize(value) {
+    return JSON.stringify(value, (_, val) => {
+        if (val instanceof Date)
+            return { __type: 'Date', value: val.toISOString() };
+        if (val instanceof RegExp)
+            return { __type: 'RegExp', value: val.toString() };
+        if (val instanceof Map)
+            return { __type: 'Map', value: Array.from(val.entries()) };
+        if (val instanceof Set)
+            return { __type: 'Set', value: Array.from(val) };
+        if (typeof val === 'bigint')
+            return { __type: 'BigInt', value: val.toString() };
+        return val;
+    });
+}
+/**
+ * Deserialize JSON with support for special types
+ */
+export function deserialize(json) {
+    return JSON.parse(json, (_, val) => {
+        if (val && typeof val === 'object' && '__type' in val) {
+            switch (val.__type) {
+                case 'Date':
+                    return new Date(val.value);
+                case 'RegExp': {
+                    const match = val.value.match(/^\/(.*)\/([gimuy]*)$/);
+                    return match ? new RegExp(match[1], match[2]) : new RegExp(val.value);
+                }
+                case 'Map':
+                    return new Map(val.value);
+                case 'Set':
+                    return new Set(val.value);
+                case 'BigInt':
+                    return BigInt(val.value);
+            }
+        }
+        return val;
+    });
+}
+/**
+ * Calculate object size in bytes (rough estimate)
+ */
+export function getObjectSize(obj) {
+    const seen = new WeakSet();
+    function calculateSize(item) {
+        if (item === null || item === undefined)
+            return 0;
+        const type = typeof item;
+        switch (type) {
+            case 'boolean':
+                return 4;
+            case 'number':
+                return 8;
+            case 'string':
+                return item.length * 2; // UTF-16
+            case 'bigint':
+                return item.toString().length;
+            case 'object':
+                if (seen.has(item))
+                    return 0;
+                seen.add(item);
+                if (item instanceof Date)
+                    return 8;
+                if (item instanceof RegExp)
+                    return item.toString().length * 2;
+                if (Array.isArray(item)) {
+                    return item.reduce((sum, val) => sum + calculateSize(val), 0);
+                }
+                return Object.entries(item).reduce((sum, [key, val]) => sum + key.length * 2 + calculateSize(val), 0);
+            default:
+                return 0;
+        }
+    }
+    return calculateSize(obj);
+}
+/**
+ * Create a simple event emitter
+ */
+export class EventEmitter {
+    events = new Map();
+    on(event, handler) {
+        if (!this.events.has(event)) {
+            this.events.set(event, new Set());
+        }
+        this.events.get(event).add(handler);
+    }
+    off(event, handler) {
+        this.events.get(event)?.delete(handler);
+    }
+    emit(event, ...args) {
+        this.events.get(event)?.forEach((handler) => {
+            try {
+                handler(...args);
+            }
+            catch (error) {
+                console.error(`Error in event handler for ${event}:`, error);
+            }
+        });
+    }
+    once(event, handler) {
+        const onceHandler = (...args) => {
+            handler(...args);
+            this.off(event, onceHandler);
+        };
+        this.on(event, onceHandler);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+    }
+}

package/ios/Plugin/KeychainStorage.swift

@@ -0,0 +1,87 @@
+import Foundation
+import Security
+
+@objc public class KeychainStorage: NSObject {
+    private let service: String
+    private let accessGroup: String?
+    
+    @objc public init(service: String? = nil, accessGroup: String? = nil) {
+        self.service = service ?? Bundle.main.bundleIdentifier ?? "StrataStorage"
+        self.accessGroup = accessGroup
+        super.init()
+    }
+    
+    @objc public func set(key: String, value: Data) -> Bool {
+        let query = createQuery(key: key)
+        SecItemDelete(query as CFDictionary)
+        
+        var newItem = query
+        newItem[kSecValueData as String] = value
+        
+        let status = SecItemAdd(newItem as CFDictionary, nil)
+        return status == errSecSuccess
+    }
+    
+    @objc public func get(key: String) -> Data? {
+        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)
+        
+        guard status == errSecSuccess else { return nil }
+        return result as? Data
+    }
+    
+    @objc public func remove(key: String) -> Bool {
+        let query = createQuery(key: key)
+        let status = SecItemDelete(query as CFDictionary)
+        return status == errSecSuccess
+    }
+    
+    @objc public func clear() -> Bool {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service
+        ]
+        let status = SecItemDelete(query as CFDictionary)
+        return status == errSecSuccess || status == errSecItemNotFound
+    }
+    
+    @objc public func keys() -> [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)
+        
+        guard status == errSecSuccess,
+              let items = result as? [[String: Any]] else { return [] }
+        
+        return items.compactMap { $0[kSecAttrAccount as String] as? String }
+    }
+    
+    private func createQuery(key: String) -> [String: Any] {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+        ]
+        
+        if let accessGroup = accessGroup {
+            query[kSecAttrAccessGroup as String] = accessGroup
+        }
+        
+        return query
+    }
+}