@pol-studios/powersync 1.0.4 → 1.0.7

package/dist/chunk-WGHNIAF7.js

@@ -0,0 +1,329 @@
+import {
+  usePowerSync
+} from "./chunk-YSTEESEG.js";
+
+// src/utils/format.ts
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["B", "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]}`;
+}
+
+// src/maintenance/database-maintenance.ts
+var CACHE_STATS_TIMEOUT_MS = 1e4;
+var TABLE_COUNT_BATCH_SIZE = 50;
+var STORAGE_WARNING_THRESHOLD = 100 * 1024 * 1024;
+var STORAGE_CRITICAL_THRESHOLD = 50 * 1024 * 1024;
+var INTERNAL_TABLES = /* @__PURE__ */ new Set(["ps_crud", "ps_oplog", "ps_buckets", "ps_untyped", "ps_tx"]);
+var USER_TABLE_PATTERN = /^ps_data__(local__)?(.+)$/;
+async function getCacheStatsImpl(db, logger) {
+  let timeoutId = null;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      logger?.warn("[getCacheStats] Query timed out after 10 seconds");
+      resolve(null);
+    }, CACHE_STATS_TIMEOUT_MS);
+  });
+  const fetchStatsPromise = (async () => {
+    try {
+      const allTables = await db.getAll(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+      const tableSizes = /* @__PURE__ */ new Map();
+      let dbstatAvailable = false;
+      try {
+        const sizeResults = await db.getAll(`SELECT COALESCE(tbl, name) as name, SUM(pgsize) as size FROM dbstat GROUP BY COALESCE(tbl, name)`);
+        logger?.debug("[getCacheStats] DBSTAT query returned", sizeResults?.length, "entries");
+        for (const row of sizeResults) {
+          const size = Number(row.size) || 0;
+          if (size > 0) {
+            tableSizes.set(row.name, size);
+            dbstatAvailable = true;
+          }
+        }
+        logger?.debug("[getCacheStats] tableSizes map has", tableSizes.size, "tables with sizes");
+      } catch (dbstatError) {
+        logger?.debug("[getCacheStats] DBSTAT query FAILED:", dbstatError);
+      }
+      const countMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < allTables.length; i += TABLE_COUNT_BATCH_SIZE) {
+        const batch = allTables.slice(i, i + TABLE_COUNT_BATCH_SIZE);
+        const batchQuery = batch.map(({
+          name
+        }) => {
+          const escapedLiteral = name.replace(/'/g, "''");
+          const escapedIdentifier = name.replace(/"/g, '""');
+          return `SELECT '${escapedLiteral}' as name, COUNT(*) as c FROM "${escapedIdentifier}"`;
+        }).join(" UNION ALL ");
+        if (batchQuery) {
+          const batchCounts = await db.getAll(batchQuery);
+          batchCounts.forEach((row) => countMap.set(row.name, Number(row.c) || 0));
+        }
+      }
+      if (!dbstatAvailable && allTables.length > 0) {
+        logger?.debug("[getCacheStats] DBSTAT unavailable, using row-count estimation fallback");
+        try {
+          const pageSizeResult = await db.get("PRAGMA page_size");
+          const pageCountResult = await db.get("PRAGMA page_count");
+          const pageSizeBytes2 = pageSizeResult?.page_size ?? 4096;
+          const totalPages2 = pageCountResult?.page_count ?? 0;
+          const totalDbBytes = pageSizeBytes2 * totalPages2;
+          let totalRowCount = 0;
+          countMap.forEach((count) => {
+            totalRowCount += count;
+          });
+          const usableBytes = totalDbBytes * 0.9;
+          if (totalRowCount > 0) {
+            for (const {
+              name
+            } of allTables) {
+              const rowCount = countMap.get(name) ?? 0;
+              if (rowCount > 0) {
+                const estimatedBytes = Math.round(rowCount / totalRowCount * usableBytes);
+                tableSizes.set(name, estimatedBytes);
+              }
+            }
+            logger?.debug("[getCacheStats] Estimated sizes for", tableSizes.size, "tables from", totalRowCount, "total rows");
+          }
+        } catch (fallbackError) {
+          logger?.debug("[getCacheStats] Size estimation fallback FAILED:", fallbackError);
+        }
+      }
+      const tableStats = [];
+      for (const {
+        name
+      } of allTables) {
+        const rowCount = countMap.get(name) ?? 0;
+        const storageBytes = tableSizes.get(name) ?? 0;
+        const match = name.match(USER_TABLE_PATTERN);
+        if (match) {
+          tableStats.push({
+            name: match[2],
+            internalName: name,
+            rowCount,
+            storageBytes,
+            storageFormatted: storageBytes > 0 ? formatBytes(storageBytes) : "N/A",
+            isInternal: false,
+            isLocalOnly: !!match[1]
+          });
+        } else if (INTERNAL_TABLES.has(name) || name.startsWith("ps_") || name.startsWith("__powersync") || name.startsWith("_powersync")) {
+          tableStats.push({
+            name,
+            internalName: name,
+            rowCount,
+            storageBytes,
+            storageFormatted: storageBytes > 0 ? formatBytes(storageBytes) : "N/A",
+            isInternal: true,
+            isLocalOnly: false
+          });
+        }
+      }
+      tableStats.sort((a, b) => {
+        if (a.isInternal !== b.isInternal) return a.isInternal ? 1 : -1;
+        return b.rowCount - a.rowCount;
+      });
+      const userTables = tableStats.filter((t) => !t.isInternal);
+      const totalRows = userTables.reduce((sum, t) => sum + t.rowCount, 0);
+      const pageSize = await db.get("PRAGMA page_size");
+      const pageCount = await db.get("PRAGMA page_count");
+      const freelistCount = await db.get("PRAGMA freelist_count");
+      const pageSizeBytes = pageSize?.page_size ?? 4096;
+      const totalPages = pageCount?.page_count ?? 0;
+      const freePages = freelistCount?.freelist_count ?? 0;
+      const usedPages = totalPages - freePages;
+      const totalBytes = pageSizeBytes * totalPages;
+      const usedBytes = pageSizeBytes * usedPages;
+      const reclaimableBytes = pageSizeBytes * freePages;
+      return {
+        tables: tableStats,
+        totalTables: userTables.length,
+        totalRows,
+        storage: {
+          used: usedBytes,
+          usedFormatted: formatBytes(usedBytes),
+          total: totalBytes,
+          totalFormatted: formatBytes(totalBytes),
+          reclaimable: reclaimableBytes,
+          reclaimableFormatted: formatBytes(reclaimableBytes)
+        }
+      };
+    } catch (err) {
+      logger?.error("[getCacheStats] error:", err);
+      return null;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  })();
+  return Promise.race([fetchStatsPromise, timeoutPromise]);
+}
+async function compactDatabaseImpl(db) {
+  try {
+    const pageSizeBefore = await db.get("PRAGMA page_size");
+    const pageCountBefore = await db.get("PRAGMA page_count");
+    const bytesBefore = (pageSizeBefore?.page_size ?? 0) * (pageCountBefore?.page_count ?? 0);
+    await db.execute("VACUUM");
+    const pageCountAfter = await db.get("PRAGMA page_count");
+    const bytesAfter = (pageSizeBefore?.page_size ?? 0) * (pageCountAfter?.page_count ?? 0);
+    return {
+      success: true,
+      bytesReclaimed: Math.max(0, bytesBefore - bytesAfter)
+    };
+  } catch (err) {
+    return {
+      success: false,
+      bytesReclaimed: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function checkIntegrityImpl(db) {
+  try {
+    const results = await db.getAll("PRAGMA integrity_check");
+    const issues = [];
+    for (const row of results) {
+      const value = row.integrity_check;
+      if (value && value !== "ok") {
+        issues.push(String(value));
+      }
+    }
+    return {
+      isHealthy: issues.length === 0,
+      issues
+    };
+  } catch (err) {
+    return {
+      isHealthy: false,
+      issues: [err instanceof Error ? err.message : String(err)]
+    };
+  }
+}
+async function checkStorageQuotaImpl(db, getFreeDiskSpace) {
+  try {
+    const freeSpace = await getFreeDiskSpace();
+    let databaseSize = 0;
+    if (db) {
+      const pageSize = await db.get("PRAGMA page_size");
+      const pageCount = await db.get("PRAGMA page_count");
+      databaseSize = (pageSize?.page_size ?? 0) * (pageCount?.page_count ?? 0);
+    }
+    let status = "ok";
+    if (freeSpace < STORAGE_CRITICAL_THRESHOLD) {
+      status = "critical";
+    } else if (freeSpace < STORAGE_WARNING_THRESHOLD) {
+      status = "warning";
+    }
+    return {
+      deviceFreeSpace: freeSpace,
+      databaseSize,
+      warningThreshold: STORAGE_WARNING_THRESHOLD,
+      criticalThreshold: STORAGE_CRITICAL_THRESHOLD,
+      status
+    };
+  } catch {
+    return {
+      deviceFreeSpace: 0,
+      databaseSize: 0,
+      warningThreshold: STORAGE_WARNING_THRESHOLD,
+      criticalThreshold: STORAGE_CRITICAL_THRESHOLD,
+      status: "critical"
+    };
+  }
+}
+
+// src/maintenance/useDatabaseMaintenance.ts
+import { c as _c } from "react/compiler-runtime";
+function useDatabaseMaintenance() {
+  const $ = _c(15);
+  const {
+    db,
+    platform
+  } = usePowerSync();
+  let t0;
+  if ($[0] !== db || $[1] !== platform.logger) {
+    t0 = async () => {
+      if (!db) {
+        return null;
+      }
+      return getCacheStatsImpl(db, platform.logger);
+    };
+    $[0] = db;
+    $[1] = platform.logger;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const getCacheStats = t0;
+  let t1;
+  if ($[3] !== db) {
+    t1 = async () => {
+      if (!db) {
+        return {
+          success: false,
+          bytesReclaimed: 0,
+          error: "Database not initialized"
+        };
+      }
+      return compactDatabaseImpl(db);
+    };
+    $[3] = db;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const compactDatabase = t1;
+  let t2;
+  if ($[5] !== db) {
+    t2 = async () => {
+      if (!db) {
+        return {
+          isHealthy: false,
+          issues: ["Database not initialized"]
+        };
+      }
+      return checkIntegrityImpl(db);
+    };
+    $[5] = db;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  const checkIntegrity = t2;
+  let t3;
+  if ($[7] !== db || $[8] !== platform.fileSystem) {
+    t3 = async () => checkStorageQuotaImpl(db, () => platform.fileSystem.getFreeDiskSpace());
+    $[7] = db;
+    $[8] = platform.fileSystem;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  const checkStorageQuota = t3;
+  let t4;
+  if ($[10] !== checkIntegrity || $[11] !== checkStorageQuota || $[12] !== compactDatabase || $[13] !== getCacheStats) {
+    t4 = {
+      getCacheStats,
+      compactDatabase,
+      checkIntegrity,
+      checkStorageQuota
+    };
+    $[10] = checkIntegrity;
+    $[11] = checkStorageQuota;
+    $[12] = compactDatabase;
+    $[13] = getCacheStats;
+    $[14] = t4;
+  } else {
+    t4 = $[14];
+  }
+  return t4;
+}
+
+export {
+  formatBytes,
+  getCacheStatsImpl,
+  compactDatabaseImpl,
+  checkIntegrityImpl,
+  checkStorageQuotaImpl,
+  useDatabaseMaintenance
+};
+//# sourceMappingURL=chunk-WGHNIAF7.js.map

package/dist/chunk-WGHNIAF7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/format.ts","../src/maintenance/database-maintenance.ts","../src/maintenance/useDatabaseMaintenance.ts"],"sourcesContent":["/**\n * Format bytes to human-readable string\n *\n * @param bytes - Number of bytes to format\n * @param decimals - Number of decimal places (default: 2)\n * @returns Formatted string like \"1.5 MB\", \"256 KB\", etc.\n */\nexport function formatBytes(bytes: number, decimals = 2): string {\n  if (bytes === 0) return '0 B';\n  const k = 1024;\n  const dm = decimals < 0 ? 0 : decimals;\n  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];\n  const i = Math.floor(Math.log(bytes) / Math.log(k));\n  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;\n}","/**\n * Pure Database Maintenance Functions for @pol-studios/powersync\n *\n * This module contains stateless, pure functions for database maintenance operations.\n * These functions can be called by hooks or used directly in other contexts.\n *\n * All functions accept the database as a parameter rather than accessing it from context,\n * making them testable and reusable across different environments.\n */\n\nimport type { AbstractPowerSyncDatabase } from '../core/types';\nimport type { LoggerAdapter } from '../platform/types';\nimport type { CacheStats, CompactResult, IntegrityResult, StorageQuota, TableCacheStats } from '../core/types';\nimport { formatBytes } from '../utils/format';\n\n// ─── Constants ────────────────────────────────────────────────────────────────\n\n/** Timeout for getCacheStats to prevent hanging if db is locked */\nconst CACHE_STATS_TIMEOUT_MS = 10000;\n\n/** Batch size for table count queries to avoid N+1 queries */\nconst TABLE_COUNT_BATCH_SIZE = 50;\n\n/** Storage warning threshold (100MB free space) */\nconst STORAGE_WARNING_THRESHOLD = 100 * 1024 * 1024;\n\n/** Storage critical threshold (50MB free space) */\nconst STORAGE_CRITICAL_THRESHOLD = 50 * 1024 * 1024;\n\n/** Known internal PowerSync tables */\nconst INTERNAL_TABLES = new Set(['ps_crud', 'ps_oplog', 'ps_buckets', 'ps_untyped', 'ps_tx']);\n\n/** Pattern to match user tables: ps_data__[local__]tablename */\nconst USER_TABLE_PATTERN = /^ps_data__(local__)?(.+)$/;\n\n// ─── Helper Types ─────────────────────────────────────────────────────────────\n\ninterface SqliteTableRow {\n  name: string;\n}\ninterface DbStatRow {\n  name: string;\n  size: number;\n}\ninterface TableCountRow {\n  name: string;\n  c: number;\n}\ninterface PageSizeRow {\n  page_size: number;\n}\ninterface PageCountRow {\n  page_count: number;\n}\ninterface FreelistCountRow {\n  freelist_count: number;\n}\ninterface IntegrityCheckRow {\n  integrity_check: string;\n}\n\n// ─── getCacheStatsImpl ────────────────────────────────────────────────────────\n\n/**\n * Get detailed cache statistics for all tables in the database.\n *\n * This function:\n * - Queries all tables from sqlite_master\n * - Tries to get table sizes from dbstat (with fallback estimation)\n * - Batches table row counts in groups of 50\n * - Calculates storage info from PRAGMA page_size, page_count, freelist_count\n *\n * @param db - The PowerSync database instance\n * @param logger - Optional logger for debug output\n * @returns Cache statistics or null if operation times out or fails\n */\nexport async function getCacheStatsImpl(db: AbstractPowerSyncDatabase, logger?: LoggerAdapter): Promise<CacheStats | null> {\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n  const timeoutPromise = new Promise<null>(resolve => {\n    timeoutId = setTimeout(() => {\n      logger?.warn('[getCacheStats] Query timed out after 10 seconds');\n      resolve(null);\n    }, CACHE_STATS_TIMEOUT_MS);\n  });\n  const fetchStatsPromise = (async (): Promise<CacheStats | null> => {\n    try {\n      // Get all tables from SQLite (excluding sqlite internal tables)\n      const allTables = await db.getAll<SqliteTableRow>(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);\n\n      // Query all table sizes from dbstat in one go\n      // Use COALESCE(tbl, name) to attribute index sizes to their parent tables\n      const tableSizes = new Map<string, number>();\n      let dbstatAvailable = false;\n      try {\n        const sizeResults = await db.getAll<DbStatRow>(`SELECT COALESCE(tbl, name) as name, SUM(pgsize) as size FROM dbstat GROUP BY COALESCE(tbl, name)`);\n        logger?.debug('[getCacheStats] DBSTAT query returned', sizeResults?.length, 'entries');\n        for (const row of sizeResults) {\n          // Handle potential type coercion issues - SQLite may return size as string or null\n          const size = Number(row.size) || 0;\n          if (size > 0) {\n            tableSizes.set(row.name, size);\n            dbstatAvailable = true;\n          }\n        }\n        logger?.debug('[getCacheStats] tableSizes map has', tableSizes.size, 'tables with sizes');\n      } catch (dbstatError) {\n        logger?.debug('[getCacheStats] DBSTAT query FAILED:', dbstatError);\n      }\n\n      // Batch table counts to avoid N+1 queries (50+ tables = 1+ second freeze)\n      const countMap = new Map<string, number>();\n      for (let i = 0; i < allTables.length; i += TABLE_COUNT_BATCH_SIZE) {\n        const batch = allTables.slice(i, i + TABLE_COUNT_BATCH_SIZE);\n        const batchQuery = batch.map(({\n          name\n        }) => {\n          // Escape quotes for SQL safety\n          const escapedLiteral = name.replace(/'/g, \"''\");\n          const escapedIdentifier = name.replace(/\"/g, '\"\"');\n          return `SELECT '${escapedLiteral}' as name, COUNT(*) as c FROM \"${escapedIdentifier}\"`;\n        }).join(' UNION ALL ');\n        if (batchQuery) {\n          const batchCounts = await db.getAll<TableCountRow>(batchQuery);\n          batchCounts.forEach(row => countMap.set(row.name, Number(row.c) || 0));\n        }\n      }\n\n      // Fallback: estimate table sizes based on row count if DBSTAT is not available\n      if (!dbstatAvailable && allTables.length > 0) {\n        logger?.debug('[getCacheStats] DBSTAT unavailable, using row-count estimation fallback');\n        try {\n          const pageSizeResult = await db.get<PageSizeRow>('PRAGMA page_size');\n          const pageCountResult = await db.get<PageCountRow>('PRAGMA page_count');\n          const pageSizeBytes = pageSizeResult?.page_size ?? 4096;\n          const totalPages = pageCountResult?.page_count ?? 0;\n          const totalDbBytes = pageSizeBytes * totalPages;\n\n          // Calculate total rows across all tables\n          let totalRowCount = 0;\n          countMap.forEach(count => {\n            totalRowCount += count;\n          });\n\n          // Distribute bytes proportionally by row count\n          // Reserve ~10% for overhead (indexes, metadata, etc.)\n          const usableBytes = totalDbBytes * 0.9;\n          if (totalRowCount > 0) {\n            for (const {\n              name\n            } of allTables) {\n              const rowCount = countMap.get(name) ?? 0;\n              if (rowCount > 0) {\n                const estimatedBytes = Math.round(rowCount / totalRowCount * usableBytes);\n                tableSizes.set(name, estimatedBytes);\n              }\n            }\n            logger?.debug('[getCacheStats] Estimated sizes for', tableSizes.size, 'tables from', totalRowCount, 'total rows');\n          }\n        } catch (fallbackError) {\n          logger?.debug('[getCacheStats] Size estimation fallback FAILED:', fallbackError);\n        }\n      }\n\n      // Build table stats array\n      const tableStats: TableCacheStats[] = [];\n      for (const {\n        name\n      } of allTables) {\n        const rowCount = countMap.get(name) ?? 0;\n        const storageBytes = tableSizes.get(name) ?? 0;\n        const match = name.match(USER_TABLE_PATTERN);\n        if (match) {\n          // User table (ps_data__[local__]tablename)\n          tableStats.push({\n            name: match[2],\n            internalName: name,\n            rowCount,\n            storageBytes,\n            storageFormatted: storageBytes > 0 ? formatBytes(storageBytes) : 'N/A',\n            isInternal: false,\n            isLocalOnly: !!match[1]\n          });\n        } else if (INTERNAL_TABLES.has(name) || name.startsWith('ps_') || name.startsWith('__powersync') || name.startsWith('_powersync')) {\n          // Internal PowerSync table\n          tableStats.push({\n            name,\n            internalName: name,\n            rowCount,\n            storageBytes,\n            storageFormatted: storageBytes > 0 ? formatBytes(storageBytes) : 'N/A',\n            isInternal: true,\n            isLocalOnly: false\n          });\n        }\n      }\n\n      // Sort: user tables first (by row count desc), then internal tables\n      tableStats.sort((a, b) => {\n        if (a.isInternal !== b.isInternal) return a.isInternal ? 1 : -1;\n        return b.rowCount - a.rowCount;\n      });\n\n      // Calculate totals for user tables only\n      const userTables = tableStats.filter(t => !t.isInternal);\n      const totalRows = userTables.reduce((sum, t) => sum + t.rowCount, 0);\n\n      // Get storage info from SQLite PRAGMAs\n      const pageSize = await db.get<PageSizeRow>('PRAGMA page_size');\n      const pageCount = await db.get<PageCountRow>('PRAGMA page_count');\n      const freelistCount = await db.get<FreelistCountRow>('PRAGMA freelist_count');\n      const pageSizeBytes = pageSize?.page_size ?? 4096;\n      const totalPages = pageCount?.page_count ?? 0;\n      const freePages = freelistCount?.freelist_count ?? 0;\n      const usedPages = totalPages - freePages;\n      const totalBytes = pageSizeBytes * totalPages;\n      const usedBytes = pageSizeBytes * usedPages;\n      const reclaimableBytes = pageSizeBytes * freePages;\n      return {\n        tables: tableStats,\n        totalTables: userTables.length,\n        totalRows,\n        storage: {\n          used: usedBytes,\n          usedFormatted: formatBytes(usedBytes),\n          total: totalBytes,\n          totalFormatted: formatBytes(totalBytes),\n          reclaimable: reclaimableBytes,\n          reclaimableFormatted: formatBytes(reclaimableBytes)\n        }\n      };\n    } catch (err) {\n      logger?.error('[getCacheStats] error:', err);\n      return null;\n    } finally {\n      if (timeoutId) clearTimeout(timeoutId);\n    }\n  })();\n\n  // Race between actual fetch and timeout\n  return Promise.race([fetchStatsPromise, timeoutPromise]);\n}\n\n// ─── compactDatabaseImpl ──────────────────────────────────────────────────────\n\n/**\n * Compact the database by running VACUUM.\n * This reclaims free pages and reduces the database file size.\n *\n * @param db - The PowerSync database instance\n * @returns Result of the compaction operation including bytes reclaimed\n */\nexport async function compactDatabaseImpl(db: AbstractPowerSyncDatabase): Promise<CompactResult> {\n  try {\n    // Get page count before VACUUM\n    const pageSizeBefore = await db.get<PageSizeRow>('PRAGMA page_size');\n    const pageCountBefore = await db.get<PageCountRow>('PRAGMA page_count');\n    const bytesBefore = (pageSizeBefore?.page_size ?? 0) * (pageCountBefore?.page_count ?? 0);\n\n    // Run VACUUM to compact the database\n    await db.execute('VACUUM');\n\n    // Get page count after VACUUM\n    const pageCountAfter = await db.get<PageCountRow>('PRAGMA page_count');\n    const bytesAfter = (pageSizeBefore?.page_size ?? 0) * (pageCountAfter?.page_count ?? 0);\n    return {\n      success: true,\n      bytesReclaimed: Math.max(0, bytesBefore - bytesAfter)\n    };\n  } catch (err) {\n    return {\n      success: false,\n      bytesReclaimed: 0,\n      error: err instanceof Error ? err.message : String(err)\n    };\n  }\n}\n\n// ─── checkIntegrityImpl ───────────────────────────────────────────────────────\n\n/**\n * Check the integrity of the database.\n * Runs SQLite's PRAGMA integrity_check.\n *\n * @param db - The PowerSync database instance\n * @returns Result indicating health status and any issues found\n */\nexport async function checkIntegrityImpl(db: AbstractPowerSyncDatabase): Promise<IntegrityResult> {\n  try {\n    const results = await db.getAll<IntegrityCheckRow>('PRAGMA integrity_check');\n    const issues: string[] = [];\n    for (const row of results) {\n      const value = row.integrity_check;\n      if (value && value !== 'ok') {\n        issues.push(String(value));\n      }\n    }\n    return {\n      isHealthy: issues.length === 0,\n      issues\n    };\n  } catch (err) {\n    return {\n      isHealthy: false,\n      issues: [err instanceof Error ? err.message : String(err)]\n    };\n  }\n}\n\n// ─── checkStorageQuotaImpl ────────────────────────────────────────────────────\n\n/**\n * Check device storage quota and database size.\n * Useful for warning users about low storage situations.\n *\n * @param db - The PowerSync database instance (can be null)\n * @param getFreeDiskSpace - Callback to get free disk space in bytes\n * @returns Storage quota information with status\n */\nexport async function checkStorageQuotaImpl(db: AbstractPowerSyncDatabase | null, getFreeDiskSpace: () => Promise<number>): Promise<StorageQuota> {\n  try {\n    const freeSpace = await getFreeDiskSpace();\n\n    // Get database size if db is available\n    let databaseSize = 0;\n    if (db) {\n      const pageSize = await db.get<PageSizeRow>('PRAGMA page_size');\n      const pageCount = await db.get<PageCountRow>('PRAGMA page_count');\n      databaseSize = (pageSize?.page_size ?? 0) * (pageCount?.page_count ?? 0);\n    }\n\n    // Determine status based on free space thresholds\n    let status: 'ok' | 'warning' | 'critical' = 'ok';\n    if (freeSpace < STORAGE_CRITICAL_THRESHOLD) {\n      status = 'critical';\n    } else if (freeSpace < STORAGE_WARNING_THRESHOLD) {\n      status = 'warning';\n    }\n    return {\n      deviceFreeSpace: freeSpace,\n      databaseSize,\n      warningThreshold: STORAGE_WARNING_THRESHOLD,\n      criticalThreshold: STORAGE_CRITICAL_THRESHOLD,\n      status\n    };\n  } catch {\n    // On error, return critical status as a safety measure\n    return {\n      deviceFreeSpace: 0,\n      databaseSize: 0,\n      warningThreshold: STORAGE_WARNING_THRESHOLD,\n      criticalThreshold: STORAGE_CRITICAL_THRESHOLD,\n      status: 'critical'\n    };\n  }\n}","import { c as _c } from \"react/compiler-runtime\";\n/**\n * React Hook for Database Maintenance Utilities\n *\n * This module provides a React hook that wraps the pure database maintenance\n * functions with stable function references via useCallback.\n */\n\nimport { useCallback } from 'react';\nimport { usePowerSync } from '../provider/hooks';\nimport type { DatabaseMaintenanceUtils } from './types';\nimport { getCacheStatsImpl, compactDatabaseImpl, checkIntegrityImpl, checkStorageQuotaImpl } from './database-maintenance';\n\n/**\n * Hook for database maintenance utilities.\n *\n * Use this hook when you need to perform database maintenance operations.\n * These operations are expensive - call sparingly (e.g., settings screens).\n *\n * Each function has a stable reference via useCallback.\n *\n * @example\n * const { getCacheStats, compactDatabase } = useDatabaseMaintenance();\n * const stats = await getCacheStats();\n */\nexport function useDatabaseMaintenance() {\n  const $ = _c(15);\n  const {\n    db,\n    platform\n  } = usePowerSync();\n  let t0;\n  if ($[0] !== db || $[1] !== platform.logger) {\n    t0 = async () => {\n      if (!db) {\n        return null;\n      }\n      return getCacheStatsImpl(db, platform.logger);\n    };\n    $[0] = db;\n    $[1] = platform.logger;\n    $[2] = t0;\n  } else {\n    t0 = $[2];\n  }\n  const getCacheStats = t0;\n  let t1;\n  if ($[3] !== db) {\n    t1 = async () => {\n      if (!db) {\n        return {\n          success: false,\n          bytesReclaimed: 0,\n          error: \"Database not initialized\"\n        };\n      }\n      return compactDatabaseImpl(db);\n    };\n    $[3] = db;\n    $[4] = t1;\n  } else {\n    t1 = $[4];\n  }\n  const compactDatabase = t1;\n  let t2;\n  if ($[5] !== db) {\n    t2 = async () => {\n      if (!db) {\n        return {\n          isHealthy: false,\n          issues: [\"Database not initialized\"]\n        };\n      }\n      return checkIntegrityImpl(db);\n    };\n    $[5] = db;\n    $[6] = t2;\n  } else {\n    t2 = $[6];\n  }\n  const checkIntegrity = t2;\n  let t3;\n  if ($[7] !== db || $[8] !== platform.fileSystem) {\n    t3 = async () => checkStorageQuotaImpl(db, () => platform.fileSystem.getFreeDiskSpace());\n    $[7] = db;\n    $[8] = platform.fileSystem;\n    $[9] = t3;\n  } else {\n    t3 = $[9];\n  }\n  const checkStorageQuota = t3;\n  let t4;\n  if ($[10] !== checkIntegrity || $[11] !== checkStorageQuota || $[12] !== compactDatabase || $[13] !== getCacheStats) {\n    t4 = {\n      getCacheStats,\n      compactDatabase,\n      checkIntegrity,\n      checkStorageQuota\n    };\n    $[10] = checkIntegrity;\n    $[11] = checkStorageQuota;\n    $[12] = compactDatabase;\n    $[13] = getCacheStats;\n    $[14] = t4;\n  } else {\n    t4 = $[14];\n  }\n  return t4;\n}"],"mappings":"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","names":["pageSizeBytes","totalPages"]}