react-native-ensys-camera-x 1.0.7

package/src/db/useMediaDatabase.ts

@@ -0,0 +1,191 @@
+/**
+ * useMediaDatabase — the clean bridge between the Media Library UI and the
+ * encrypted SQLCipher store.
+ *
+ * The screen renders `CameraAsset`s and never touches SQL: it consumes this
+ * hook's state (`assets`, `counts`, `loading`) and calls its actions
+ * (`addAssets`, `removeById`, `refresh`). Every mutation writes to SQLCipher
+ * first, then refreshes derived state from the database so the list and the
+ * filter-card counters always stay in sync with persistence.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { CameraAsset, SecureDeleteResult } from '../types';
+// Imported from the TurboModule directly, NOT from '../index': index re-exports this
+// hook, so going through it would close an import cycle.
+import CustomCamera from '../NativeCustomCamera';
+import { initializeMediaDatabase } from './DatabaseManager';
+import { getMediaRepository } from './MediaRepository';
+import { recordToAsset } from './MediaMapper';
+import type { MediaCounts, MediaSource } from './types';
+
+const EMPTY_COUNTS: MediaCounts = {
+  all: 0,
+  image: 0,
+  video: 0,
+  document: 0,
+  audio: 0,
+};
+
+export interface UseMediaDatabaseResult {
+  /** All media as UI assets, newest first — the single source of truth. */
+  assets: CameraAsset[];
+  /** Filter-card counters computed directly from the database. */
+  counts: MediaCounts;
+  /** True during the initial load. */
+  loading: boolean;
+  /** Non-null if initialization/loading failed. */
+  error: Error | null;
+  /** Persist captured/selected assets, then refresh state from the DB. */
+  addAssets: (
+    assets: CameraAsset[],
+    source?: MediaSource
+  ) => Promise<CameraAsset[]>;
+  /** Delete one media item from the DB and update state. */
+  removeById: (id: string) => Promise<void>;
+  /** Delete several media items from the DB and update state. */
+  removeMany: (ids: string[]) => Promise<void>;
+  /**
+   * Securely destroy one media item's FILE and then remove its SQLCipher row.
+   *
+   * This is the deletion path to prefer over {@link removeById}, which only drops
+   * the database row and leaves the media on disk. Here the native layer measures
+   * the file's exact size, overwrites it with encrypted cryptographically secure
+   * random data 2 MB larger than that size, flushes it to storage, unlinks it, and
+   * sweeps thumbnails, cached copies and derived variants — and only then is the
+   * row deleted and the list refreshed.
+   *
+   * The row is removed even when the secure overwrite fails, because the user
+   * asked for the item to be gone; the returned report says what actually
+   * happened, and only `fullySecure` justifies telling them it was securely
+   * erased. Returns null when no row exists for `id`.
+   */
+  secureRemoveById: (id: string) => Promise<SecureDeleteResult | null>;
+  /** Re-read everything from the DB (list + counts). */
+  refresh: () => Promise<void>;
+}
+
+/**
+ * @param autoInit when true (default) the hook opens the DB and loads on mount.
+ */
+export function useMediaDatabase(autoInit = true): UseMediaDatabaseResult {
+  const [assets, setAssets] = useState<CameraAsset[]>([]);
+  const [counts, setCounts] = useState<MediaCounts>(EMPTY_COUNTS);
+  const [loading, setLoading] = useState<boolean>(autoInit);
+  const [error, setError] = useState<Error | null>(null);
+  const mountedRef = useRef(true);
+
+  const repo = getMediaRepository();
+
+  /** Reloads the full list and counts from SQLCipher. */
+  const refresh = useCallback(async () => {
+    const [records, freshCounts] = await Promise.all([
+      repo.getAll(),
+      repo.getCounts(),
+    ]);
+    if (!mountedRef.current) return;
+    setAssets(records.map(recordToAsset));
+    setCounts(freshCounts);
+  }, [repo]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    if (!autoInit) return;
+
+    (async () => {
+      try {
+        await initializeMediaDatabase();
+        await refresh();
+      } catch (err) {
+        if (mountedRef.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        // Keep the app usable even if the encrypted DB can't open (e.g. web).
+        console.warn('[useMediaDatabase] initialization failed:', err);
+      } finally {
+        if (mountedRef.current) setLoading(false);
+      }
+    })();
+
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [autoInit, refresh]);
+
+  const addAssets = useCallback(
+    async (incoming: CameraAsset[], source?: MediaSource) => {
+      if (!incoming || incoming.length === 0) return [];
+      // The repository persists ONLY assets confirmed in the Documents directory
+      // and auto-detects the origin when `source` is omitted. It returns just the
+      // records actually written (cache-only/publish-failed assets are skipped).
+      const records = await repo.insertAssets(incoming, source);
+      // Re-read from the DB so the list + counters reflect exactly what was
+      // persisted — the single source of truth.
+      await refresh();
+      return records.map(recordToAsset);
+    },
+    [repo, refresh]
+  );
+
+  const removeById = useCallback(
+    async (id: string) => {
+      await repo.deleteById(id);
+      await refresh();
+    },
+    [repo, refresh]
+  );
+
+  const removeMany = useCallback(
+    async (ids: string[]) => {
+      await repo.deleteMany(ids);
+      await refresh();
+    },
+    [repo, refresh]
+  );
+
+  const secureRemoveById = useCallback(
+    async (id: string): Promise<SecureDeleteResult | null> => {
+      const record = await repo.getById(id);
+      if (!record) return null;
+
+      // The FILE goes first. Deleting the row first would strand the media on disk
+      // with nothing left pointing at it — unreachable from the UI, but fully
+      // intact and recoverable, which is the opposite of what a delete promises.
+      let report: SecureDeleteResult | null = null;
+      try {
+        report = (await CustomCamera.secureDeleteMedia(record.filePath, {
+          assetId: record.id,
+          fileName: record.fileName,
+        })) as SecureDeleteResult;
+      } catch (err) {
+        // Swallowed deliberately: the row is still removed below so the item does
+        // not linger in the library, and the null report tells the caller the
+        // secure-erase guarantee was NOT met.
+        console.warn('[useMediaDatabase] secure erase failed for', id, err);
+      }
+
+      if (report && !report.fullySecure) {
+        console.warn(
+          '[useMediaDatabase] media removed without a verified secure erase:',
+          JSON.stringify(report)
+        );
+      }
+
+      await repo.deleteById(id);
+      await refresh();
+      return report;
+    },
+    [repo, refresh]
+  );
+
+  return {
+    assets,
+    counts,
+    loading,
+    error,
+    addAssets,
+    removeById,
+    removeMany,
+    secureRemoveById,
+    refresh,
+  };
+}