@ursalock/zustand 0.3.0 → 0.4.0

package/dist/vault.js

@@ -1,261 +0,0 @@
-/**
- * vault() middleware - Drop-in replacement for persist()
- * Adds E2EE encryption and cloud sync to Zustand stores
- *
- * Supports two encryption modes:
- * - Legacy: recoveryKey string (Argon2id key derivation)
- * - New: cipherJwk from ZKCredentials (PRF-derived)
- *
- * Type pattern follows zustand's persist middleware:
- * - Simple internal implementation type (VaultImpl)
- * - Complex public API type (Vault)
- * - Cast at export: `vaultImpl as unknown as Vault`
- */
-import { createVaultStorage } from "./storage.js";
-import { createSyncEngine } from "./sync.js";
-/** Log a caught error from a fire-and-forget promise */
-const logCatch = (context) => (err) => console.error(`[ursalock] ${context}:`, err);
-/** Helper to check if using JWK mode */
-function isJwkMode(options) {
-    return "cipherJwk" in options;
-}
-/**
- * Internal vault implementation
- * Uses simplified types - complex types applied at export
- */
-const vaultImpl = (config, baseOptions) => (set, get, api) => {
-    const options = {
-        partialize: (state) => state,
-        merge: (persistedState, currentState) => ({
-            ...currentState,
-            ...persistedState,
-        }),
-        syncInterval: 30000,
-        ...baseOptions,
-    };
-    const { name, server, getToken, partialize, merge, onRehydrateStorage, skipHydration = false, syncInterval, } = options;
-    // Create encrypted storage based on mode
-    const storage = options.storage ?? createVaultStorage(isJwkMode(options)
-        ? { cipherJwk: options.cipherJwk, prefix: options.prefix }
-        : { recoveryKey: options.recoveryKey, prefix: options.prefix });
-    // State
-    let hasHydrated = false;
-    let localUpdatedAt = 0; // Start at 0 - server data wins until we have local changes
-    let hasLocalData = false; // Track if we loaded data from local storage
-    let syncDebounceTimer = null;
-    const hydrationListeners = new Set();
-    const finishHydrationListeners = new Set();
-    // Create sync engine (if server configured)
-    let syncEngine = null;
-    if (server && getToken) {
-        syncEngine = createSyncEngine({
-            serverUrl: server,
-            name,
-            getToken,
-            onServerData: (data, _salt, updatedAt) => {
-                // Server has newer data, update local store
-                // Only pull if we haven't made local changes since last sync
-                if (localUpdatedAt > updatedAt) {
-                    // Local is actually newer - don't overwrite, push instead
-                    void syncEngine?.push().catch(logCatch("Push after local-newer conflict"));
-                    return;
-                }
-                try {
-                    const parsed = JSON.parse(data);
-                    const merged = merge(parsed, get());
-                    set(merged, true);
-                    localUpdatedAt = updatedAt;
-                    // Also persist to local storage to keep in sync
-                    void storage.setItem(name, JSON.stringify(partialize({ ...get() }))).catch(logCatch("Persist server data to local storage"));
-                }
-                catch (err) {
-                    console.error("[ursalock] Failed to parse server data:", err);
-                }
-            },
-            getLocalData: () => {
-                // Get current encrypted local data
-                const state = partialize({ ...get() });
-                return {
-                    data: JSON.stringify(state),
-                    salt: "", // Salt is handled by storage layer
-                    updatedAt: localUpdatedAt,
-                };
-            },
-        });
-    }
-    // Persist to storage and trigger debounced sync
-    const persistState = async () => {
-        const state = partialize({ ...get() });
-        await storage.setItem(name, JSON.stringify(state));
-        localUpdatedAt = Date.now();
-        // Debounced sync after changes (3 seconds)
-        if (syncEngine) {
-            if (syncDebounceTimer) {
-                clearTimeout(syncDebounceTimer);
-            }
-            syncDebounceTimer = setTimeout(() => {
-                syncDebounceTimer = null;
-                void syncEngine?.sync().catch(logCatch("Debounced sync"));
-            }, 3000);
-        }
-    };
-    // Hydrate from storage
-    const rehydrate = async () => {
-        hasHydrated = false;
-        hydrationListeners.forEach((cb) => cb(get()));
-        const postRehydrationCallback = onRehydrateStorage?.(get()) || undefined;
-        try {
-            const stored = await storage.getItem(name);
-            if (stored) {
-                const parsed = JSON.parse(stored);
-                const merged = merge(parsed, get());
-                set(merged, true);
-                hasLocalData = true;
-                // Don't set localUpdatedAt here - keep at 0 so first sync pulls from server
-                // localUpdatedAt will be set properly after first successful sync or local change
-            }
-            hasHydrated = true;
-            postRehydrationCallback?.(get(), undefined);
-            finishHydrationListeners.forEach((cb) => cb(get()));
-        }
-        catch (error) {
-            postRehydrationCallback?.(undefined, error);
-        }
-    };
-    // Sync methods (delegate to sync engine)
-    const sync = async () => {
-        if (!syncEngine)
-            return;
-        await syncEngine.sync();
-    };
-    const push = async () => {
-        if (!syncEngine)
-            return;
-        await syncEngine.push();
-    };
-    const pull = async () => {
-        if (!syncEngine)
-            return false;
-        return syncEngine.pull();
-    };
-    const getSyncStatus = () => {
-        if (!syncEngine)
-            return "idle";
-        return syncEngine.getState().status;
-    };
-    const hasPendingChanges = () => {
-        if (!syncEngine)
-            return false;
-        return syncEngine.getState().pendingChanges;
-    };
-    // Clear storage
-    const clearStorage = async () => {
-        await storage.removeItem(name);
-        syncEngine?.clearQueue();
-    };
-    const savedSetState = api.setState;
-    api.setState = ((state, replace) => {
-        if (replace) {
-            savedSetState(state, true);
-        }
-        else {
-            savedSetState(state);
-        }
-        void persistState().catch(logCatch("Persist state"));
-    });
-    // Create store with wrapped set
-    const configResult = config(((partial, replace) => {
-        if (replace) {
-            set(partial, true);
-        }
-        else {
-            set(partial);
-        }
-        void persistState().catch(logCatch("Persist state"));
-    }), get, api);
-    // Extend API with vault methods
-    const storeWithVault = api;
-    storeWithVault.vault = {
-        sync,
-        push,
-        pull,
-        rehydrate,
-        hasHydrated: () => hasHydrated,
-        getSyncStatus,
-        hasPendingChanges,
-        clearStorage,
-        onHydrate: (cb) => {
-            hydrationListeners.add(cb);
-            return () => hydrationListeners.delete(cb);
-        },
-        onFinishHydration: (cb) => {
-            finishHydrationListeners.add(cb);
-            return () => finishHydrationListeners.delete(cb);
-        },
-    };
-    // Auto-hydrate on init (unless skipHydration)
-    if (!skipHydration) {
-        void rehydrate().then(() => {
-            // Sync immediately after hydration to get latest server data
-            if (syncEngine) {
-                void syncEngine.sync().catch(logCatch("Initial sync after hydration"));
-            }
-        }).catch(logCatch("Auto-rehydration"));
-    }
-    else {
-        // Even with skipHydration, mark as hydrated to allow persistence
-        hasHydrated = true;
-    }
-    // Setup sync interval (if server configured)
-    let syncIntervalId = null;
-    if (server && syncInterval > 0) {
-        syncIntervalId = setInterval(() => void sync().catch(logCatch("Periodic sync")), syncInterval);
-    }
-    // Expose destroy method to clean up interval
-    const vaultApi = storeWithVault.vault;
-    vaultApi.destroy = () => {
-        if (syncIntervalId) {
-            clearInterval(syncIntervalId);
-            syncIntervalId = null;
-        }
-        if (syncDebounceTimer) {
-            clearTimeout(syncDebounceTimer);
-            syncDebounceTimer = null;
-        }
-    };
-    return configResult;
-};
-/**
- * vault() middleware - Add E2EE encrypted persistence to Zustand
- *
- * @example Using CipherJWK from ZKCredentials (recommended)
- * ```ts
- * const useStore = create(
- *   vault(
- *     (set) => ({
- *       count: 0,
- *       increment: () => set((s) => ({ count: s.count + 1 })),
- *     }),
- *     {
- *       name: 'my-store',
- *       cipherJwk: credential.cipherJwk, // From ZKCredentials
- *       server: 'https://vault.example.com', // optional
- *     }
- *   )
- * )
- * ```
- *
- * @example Using recovery key (legacy)
- * ```ts
- * const useStore = create(
- *   vault(
- *     (set) => ({ ... }),
- *     {
- *       name: 'my-store',
- *       recoveryKey: 'ABCD-EFGH-...',
- *     }
- *   )
- * )
- * ```
- */
-export const vault = vaultImpl;