local-lite 0.0.14 → 0.0.16

package/dist/react/backups.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCloudBackup = useCloudBackup;
+exports.useGoogleDriveBackup = useGoogleDriveBackup;
+exports.useOneDriveBackup = useOneDriveBackup;
+const react_1 = require("react");
+const index_js_1 = require("../backups/index.js");
+function useCloudBackup(client, database, options) {
+    const [isConnected, setIsConnected] = (0, react_1.useState)(false);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const [isBackingUp, setIsBackingUp] = (0, react_1.useState)(false);
+    const [isRestoring, setIsRestoring] = (0, react_1.useState)(false);
+    const [backups, setBackups] = (0, react_1.useState)([]);
+    const [lastBackupAt, setLastBackupAt] = (0, react_1.useState)(null);
+    const [error, setError] = (0, react_1.useState)(null);
+    const databaseRef = (0, react_1.useRef)(database);
+    databaseRef.current = database;
+    const defaultPassphrase = options?.passphrase;
+    const autoRefresh = options?.autoRefresh ?? true;
+    const refreshBackups = (0, react_1.useCallback)(async () => {
+        if (!client) {
+            setBackups([]);
+            return [];
+        }
+        try {
+            const connected = await client.isConnected();
+            if (!connected) {
+                setBackups([]);
+                return [];
+            }
+            const list = await client.list();
+            setBackups(list);
+            return list;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+    }, [client]);
+    (0, react_1.useEffect)(() => {
+        if (!client) {
+            setIsConnected(false);
+            setIsLoading(false);
+            setBackups([]);
+            return;
+        }
+        let isMounted = true;
+        setIsLoading(true);
+        client
+            .isConnected()
+            .then(async (connected) => {
+            if (!isMounted)
+                return;
+            setIsConnected(connected);
+            setIsLoading(false);
+            if (connected && autoRefresh) {
+                try {
+                    const list = await client.list();
+                    if (isMounted)
+                        setBackups(list);
+                }
+                catch (listErr) {
+                    if (isMounted) {
+                        setError(listErr instanceof Error ? listErr : new Error(String(listErr)));
+                    }
+                }
+            }
+        })
+            .catch(err => {
+            if (!isMounted)
+                return;
+            setError(err instanceof Error ? err : new Error(String(err)));
+            setIsLoading(false);
+        });
+        let unsubscribe;
+        if (typeof client.onStatusChange === 'function') {
+            unsubscribe = client.onStatusChange(async (connected) => {
+                if (!isMounted)
+                    return;
+                setIsConnected(connected);
+                if (connected && autoRefresh) {
+                    try {
+                        const list = await client.list();
+                        if (isMounted)
+                            setBackups(list);
+                    }
+                    catch (listErr) {
+                        if (isMounted) {
+                            setError(listErr instanceof Error ? listErr : new Error(String(listErr)));
+                        }
+                    }
+                }
+                else if (!connected) {
+                    setBackups([]);
+                }
+            });
+        }
+        return () => {
+            isMounted = false;
+            if (unsubscribe)
+                unsubscribe();
+        };
+    }, [client, autoRefresh]);
+    const connect = (0, react_1.useCallback)(async () => {
+        if (!client)
+            throw new Error('Cloud backup client is not initialized.');
+        setError(null);
+        setIsLoading(true);
+        try {
+            const connected = await client.connect();
+            setIsConnected(connected);
+            if (connected && autoRefresh) {
+                const list = await client.list();
+                setBackups(list);
+            }
+            return connected;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client, autoRefresh]);
+    const disconnect = (0, react_1.useCallback)(async () => {
+        if (!client)
+            return;
+        setError(null);
+        setIsLoading(true);
+        try {
+            await client.disconnect();
+            setIsConnected(false);
+            setBackups([]);
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    const backup = (0, react_1.useCallback)(async (backupOptions) => {
+        if (!client)
+            throw new Error('Cloud backup client is not initialized.');
+        const currentDb = databaseRef.current;
+        if (!currentDb) {
+            throw new Error('A database instance or LocalFirstClient must be provided to create a backup.');
+        }
+        setError(null);
+        setIsBackingUp(true);
+        try {
+            const passphrase = backupOptions?.passphrase ?? defaultPassphrase;
+            let createdFileName;
+            if (typeof client.backup === 'function') {
+                createdFileName = await client.backup(currentDb, {
+                    fileName: backupOptions?.fileName,
+                    passphrase,
+                });
+            }
+            else {
+                createdFileName = await (0, index_js_1.performBackup)(currentDb, client, {
+                    fileName: backupOptions?.fileName,
+                    passphrase,
+                });
+            }
+            setLastBackupAt(new Date().toISOString());
+            if (autoRefresh) {
+                try {
+                    const list = await client.list();
+                    setBackups(list);
+                }
+                catch {
+                    // Backup succeeded; silent list update failure is tolerated
+                }
+            }
+            return createdFileName;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsBackingUp(false);
+        }
+    }, [client, defaultPassphrase, autoRefresh]);
+    const restore = (0, react_1.useCallback)(async (fileNameOrId, restoreOptions) => {
+        if (!client)
+            throw new Error('Cloud backup client is not initialized.');
+        const currentDb = databaseRef.current;
+        if (!currentDb) {
+            throw new Error('A database instance or LocalFirstClient must be provided to restore a backup.');
+        }
+        setError(null);
+        setIsRestoring(true);
+        try {
+            const passphrase = restoreOptions?.passphrase ?? defaultPassphrase;
+            if (typeof client.restore === 'function') {
+                await client.restore(currentDb, fileNameOrId, { passphrase });
+            }
+            else {
+                await (0, index_js_1.performRestore)(currentDb, client, fileNameOrId, { passphrase });
+            }
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsRestoring(false);
+        }
+    }, [client, defaultPassphrase]);
+    const deleteBackup = (0, react_1.useCallback)(async (fileNameOrId) => {
+        if (!client)
+            throw new Error('Cloud backup client is not initialized.');
+        setError(null);
+        try {
+            if (typeof client.deleteBackup === 'function') {
+                await client.deleteBackup(fileNameOrId);
+            }
+            else if (typeof client.delete === 'function') {
+                await client.delete(fileNameOrId);
+            }
+            else {
+                throw new Error('Delete operation is not supported by this cloud storage client.');
+            }
+            if (autoRefresh) {
+                const list = await client.list();
+                setBackups(list);
+            }
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+    }, [client, autoRefresh]);
+    return {
+        isConnected,
+        isLoading,
+        isBackingUp,
+        isRestoring,
+        backups,
+        lastBackupAt,
+        error,
+        connect,
+        disconnect,
+        refreshBackups,
+        backup,
+        restore,
+        deleteBackup,
+    };
+}
+function useGoogleDriveBackup(client, database, options) {
+    return useCloudBackup(client, database, options);
+}
+function useOneDriveBackup(client, database, options) {
+    return useCloudBackup(client, database, options);
+}

package/dist/react/index.d.ts

@@ -111,10 +111,23 @@ export interface UseMutationsResult<TTable extends string = string> {
  * Universal mutations hook providing memoized, null-safe helpers for database operations.
  */
 export declare function useMutations<TTable extends string = string>(client: LocalFirstClient | null | undefined): UseMutationsResult<TTable>;
+export interface UseDatabaseMaintenanceResult {
+    stats: import('../core/maintenance.js').StorageStats | null;
+    loading: boolean;
+    refreshStats: () => Promise<import('../core/maintenance.js').StorageStats | null>;
+    pruneOutbox: (options?: import('../core/maintenance.js').PruneOutboxOptions) => Promise<number>;
+    vacuum: () => Promise<void>;
+    checkpoint: (mode?: import('../core/maintenance.js').CheckpointMode) => Promise<void>;
+}
+/**
+ * Reactive hook for database maintenance (vacuum, WAL checkpoint, outbox pruning, and storage metrics).
+ */
+export declare function useDatabaseMaintenance(client: LocalFirstClient | null | undefined): UseDatabaseMaintenanceResult;
 export * from './runner.js';
 export * from './status.js';
 export * from './theme.js';
 export * from './BenchmarkModal.js';
-export { SyncInspector, SyncIndicator } from './SyncInspector.js';
-export type { SyncInspectorProps, SyncIndicatorProps } from './SyncInspector.js';
+export { SyncInspector } from './SyncInspector.js';
+export type { SyncInspectorProps } from './SyncInspector.js';
 export * from './auth.js';
+export * from './backups.js';

package/dist/react/index.js

@@ -14,13 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncIndicator = exports.SyncInspector = void 0;
+exports.SyncInspector = void 0;
 exports.clearLiveQueryCache = clearLiveQueryCache;
 exports.useLiveQuery = useLiveQuery;
 exports.useLiveQueries = useLiveQueries;
 exports.useLiveRow = useLiveRow;
 exports.useLiveInfiniteQuery = useLiveInfiniteQuery;
 exports.useMutations = useMutations;
+exports.useDatabaseMaintenance = useDatabaseMaintenance;
 const react_1 = require("react");
 const runner_js_1 = require("./runner.js");
 function areRowsEqual(a, b) {
@@ -587,11 +588,61 @@ function useMutations(client) {
         transaction: (action) => client ? client.transaction(action) : Promise.resolve(undefined),
     }), [client]);
 }
+/**
+ * Reactive hook for database maintenance (vacuum, WAL checkpoint, outbox pruning, and storage metrics).
+ */
+function useDatabaseMaintenance(client) {
+    const [stats, setStats] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const refreshStats = (0, react_1.useCallback)(async () => {
+        if (!client)
+            return null;
+        setLoading(true);
+        try {
+            const res = await client.maintenance.getStorageStats();
+            setStats(res);
+            return res;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client]);
+    const pruneOutbox = (0, react_1.useCallback)(async (options) => {
+        if (!client)
+            return 0;
+        const count = await client.maintenance.pruneOutbox(options);
+        await refreshStats();
+        return count;
+    }, [client, refreshStats]);
+    const vacuum = (0, react_1.useCallback)(async () => {
+        if (!client)
+            return;
+        await client.maintenance.vacuum();
+        await refreshStats();
+    }, [client, refreshStats]);
+    const checkpoint = (0, react_1.useCallback)(async (mode) => {
+        if (!client)
+            return;
+        await client.maintenance.checkpoint(mode);
+        await refreshStats();
+    }, [client, refreshStats]);
+    return {
+        stats,
+        loading,
+        refreshStats,
+        pruneOutbox,
+        vacuum,
+        checkpoint,
+    };
+}
 __exportStar(require("./runner.js"), exports);
 __exportStar(require("./status.js"), exports);
 __exportStar(require("./theme.js"), exports);
 __exportStar(require("./BenchmarkModal.js"), exports);
 var SyncInspector_js_1 = require("./SyncInspector.js");
 Object.defineProperty(exports, "SyncInspector", { enumerable: true, get: function () { return SyncInspector_js_1.SyncInspector; } });
-Object.defineProperty(exports, "SyncIndicator", { enumerable: true, get: function () { return SyncInspector_js_1.SyncIndicator; } });
 __exportStar(require("./auth.js"), exports);
+__exportStar(require("./backups.js"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-lite",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Never let a lost connection break a promise. Local-first sync that faithfully keeps data safe until you're back online.",
   "license": "MIT",
   "main": "dist/index.js",
@@ -56,6 +56,16 @@
       "import": "./dist/backups/index.js",
       "default": "./dist/backups/index.js"
     },
+    "./portability": {
+      "types": "./dist/utils/portability.d.ts",
+      "import": "./dist/utils/portability.js",
+      "default": "./dist/utils/portability.js"
+    },
+    "./maintenance": {
+      "types": "./dist/core/maintenance.d.ts",
+      "import": "./dist/core/maintenance.js",
+      "default": "./dist/core/maintenance.js"
+    },
     "./expo-sqlite": {
       "types": "./dist/adapters/local/expo-sqlite.d.ts",
       "import": "./dist/adapters/local/expo-sqlite.js",