react-native-ensys-camera-x 1.0.7

package/src/db/MediaMapper.ts

@@ -0,0 +1,377 @@
+/**
+ * MediaMapper — the single translation boundary between the UI-facing
+ * `CameraAsset` type and the persisted `MediaRecord`/SQL row.
+ *
+ * Keeping all field mapping here means the rest of the app (screens, hooks) and
+ * the database schema can evolve independently. Two directions are supported:
+ *   - `assetToRecordInput`  CameraAsset  → MediaRecordInput (for writes)
+ *   - `rowToRecord` / `recordToAsset`   SQL row → MediaRecord → CameraAsset (reads)
+ */
+import type { CameraAsset } from '../types';
+import {
+  MediaColumns,
+  type MediaRecord,
+  type MediaRecordInput,
+  type MediaSource,
+  type MediaType,
+} from './types';
+
+/**
+ * UI uses `photo`; the database normalizes photos to `image`. Videos, documents
+ * and audio are preserved as-is so a picked PDF or track keeps its true kind
+ * instead of collapsing into `image` (the historical cause of documents/audio
+ * showing up under the Photos filter).
+ */
+export function assetTypeToMediaType(type: CameraAsset['type']): MediaType {
+  switch (type) {
+    case 'video':
+      return 'video';
+    case 'document':
+      return 'document';
+    case 'audio':
+      return 'audio';
+    default:
+      return 'image';
+  }
+}
+
+/** Inverse of {@link assetTypeToMediaType}. */
+export function mediaTypeToAssetType(type: MediaType): CameraAsset['type'] {
+  switch (type) {
+    case 'video':
+      return 'video';
+    case 'document':
+      return 'document';
+    case 'audio':
+      return 'audio';
+    default:
+      return 'photo';
+  }
+}
+
+// Extension → kind tables. Used as a fallback (and cross-check) when the MIME
+// type is missing or generic, so classification never relies on a single signal.
+const IMAGE_EXTS = new Set([
+  'jpg',
+  'jpeg',
+  'png',
+  'gif',
+  'webp',
+  'bmp',
+  'heic',
+  'heif',
+  'hif',
+  'avif',
+  'avifs',
+  'tif',
+  'tiff',
+]);
+const VIDEO_EXTS = new Set([
+  'mp4',
+  'mov',
+  'mkv',
+  'webm',
+  'avi',
+  '3gp',
+  '3gpp',
+  'm4v',
+  'mpg',
+  'mpeg',
+]);
+const AUDIO_EXTS = new Set([
+  'mp3',
+  'wav',
+  'aac',
+  'm4a',
+  'ogg',
+  'oga',
+  'flac',
+  'opus',
+  'amr',
+  'mid',
+  'midi',
+]);
+const DOCUMENT_EXTS = new Set([
+  'pdf',
+  'doc',
+  'docx',
+  'xls',
+  'xlsx',
+  'ppt',
+  'pptx',
+  'txt',
+  'csv',
+  'rtf',
+  'odt',
+  'ods',
+  'odp',
+  'epub',
+  'md',
+]);
+
+function extensionOf(fileName?: string | null): string | null {
+  if (!fileName) return null;
+  const dot = fileName.lastIndexOf('.');
+  if (dot < 0 || dot === fileName.length - 1) return null;
+  return fileName.slice(dot + 1).toLowerCase();
+}
+
+/** The extension a path/URI ends in, ignoring any query string and the directories above it. */
+function extensionOfPath(path?: string | null): string | null {
+  if (!path) return null;
+  const withoutQuery = path.split(/[?#]/)[0] ?? '';
+  return extensionOf(withoutQuery.split(/[\\/]/).pop());
+}
+
+// Image MIME types whose container is worth preserving in a synthesized file name. Mirrors the
+// native ImageFormatSupport table: naming a GIF `.jpg` puts JPEG's name on bytes that
+// start with GIF89a, and consumers then fail to render it.
+const MIME_TO_EXTENSION: Record<string, string> = {
+  'image/gif': 'gif',
+  'image/png': 'png',
+  'image/webp': 'webp',
+  'image/heic': 'heic',
+  'image/heif': 'heif',
+  'image/heic-sequence': 'heic',
+  'image/heif-sequence': 'heif',
+  'image/avif': 'avif',
+  'image/bmp': 'bmp',
+  'image/jpeg': 'jpg',
+};
+
+/**
+ * The file extension a synthesized name should carry for `mimeType`, defaulting to the given
+ * fallback when the type is missing or unrecognised.
+ */
+export function extensionForMimeType(
+  mimeType: string | null | undefined,
+  fallback: string
+): string {
+  if (!mimeType) return fallback;
+  return MIME_TO_EXTENSION[mimeType.toLowerCase()] ?? fallback;
+}
+
+/**
+ * Resolves the canonical persisted {@link MediaType} for an asset using every
+ * available signal — the caller-provided `type`, the MIME type, then the file
+ * extension — so a mis-tagged or MIME-less item is still classified correctly.
+ * Order of precedence: a document path → MIME family → extension → the UI `type`
+ * fallback.
+ */
+export function classifyMediaType(asset: CameraAsset): MediaType {
+  const mime = asset.mimeType?.toLowerCase() ?? '';
+
+  // The FILE outranks an `image/*` MIME type when the file itself names a document container.
+  // "Export By → PDF" turns a photo into a PDF, and an asset that carries the source photo's
+  // metadata — because it was written before the export re-stated it — says `image/jpeg` while
+  // its path ends in `.pdf`. Trusting the MIME there stored the PDF as an image: it was filed
+  // under Photos and handed to the image decoder, which has no idea what a PDF is, so the
+  // preview came up blank.
+  const pathExtension = extensionOfPath(resolveDocumentsPath(asset) ?? asset.uri);
+  if (
+    pathExtension &&
+    DOCUMENT_EXTS.has(pathExtension) &&
+    (!mime || mime.startsWith('image/'))
+  ) {
+    return 'document';
+  }
+
+  if (mime.startsWith('image/')) return 'image';
+  if (mime.startsWith('video/')) return 'video';
+  if (mime.startsWith('audio/')) return 'audio';
+  if (isDocumentMime(mime)) return 'document';
+
+  const ext = extensionOf(asset.fileName);
+  if (ext) {
+    if (IMAGE_EXTS.has(ext)) return 'image';
+    if (VIDEO_EXTS.has(ext)) return 'video';
+    if (AUDIO_EXTS.has(ext)) return 'audio';
+    if (DOCUMENT_EXTS.has(ext)) return 'document';
+  }
+
+  // Nothing conclusive from mime/extension: trust the type the picker assigned.
+  return assetTypeToMediaType(asset.type);
+}
+
+/** True for MIME strings that denote a document (non image/video/audio) file. */
+function isDocumentMime(mime: string): boolean {
+  if (!mime) return false;
+  if (
+    mime.startsWith('image/') ||
+    mime.startsWith('video/') ||
+    mime.startsWith('audio/')
+  ) {
+    return false;
+  }
+  return (
+    mime === 'application/pdf' ||
+    mime.startsWith('application/vnd.') ||
+    mime.startsWith('application/msword') ||
+    mime.startsWith('application/rtf') ||
+    mime === 'application/epub+zip' ||
+    mime.startsWith('text/')
+  );
+}
+
+/** Normalizes an arbitrary source hint onto the allowed enum. */
+export function normalizeSource(source: unknown): MediaSource {
+  return source === 'gallery' ? 'gallery' : 'camera';
+}
+
+/**
+ * Resolves the FINAL, persistent Documents path for an asset — the path that
+ * must be stored in SQLCipher — or `null` if the asset is not (yet) in the
+ * Documents directory.
+ *
+ * The native Send workflow moves a confirmed file from cache to
+ * `.../Documents/media_documents/...`, clears `cachePath`, and sets
+ * `documentUri`. This helper therefore prefers `documentUri`, then falls back to
+ * `uri` ONLY when that uri is itself a published Documents path (not a cache or
+ * `content://` gallery path). A still-cached / publish-failed asset returns
+ * `null`, so callers can skip it and never persist a temporary location.
+ */
+export function resolveDocumentsPath(asset: CameraAsset): string | null {
+  const documentUri = (asset as { documentUri?: string }).documentUri;
+  if (documentUri && documentUri.length > 0) {
+    return documentUri;
+  }
+  const uri = asset.uri ?? '';
+  if (uri.length > 0) {
+    return uri;
+  }
+  return null;
+}
+
+/**
+ * True when an asset has been successfully moved to the Documents directory and
+ * is therefore eligible to be persisted in SQLCipher. Cache-only or
+ * publish-failed assets return false.
+ */
+export function isPublishedToDocuments(asset: CameraAsset): boolean {
+  return resolveDocumentsPath(asset) !== null;
+}
+
+/**
+ * Auto-detects the origin of an asset. Gallery-selected media retains its
+ * original `content://`/gallery uri in `originalUri`; camera captures do not.
+ * An explicit hint always wins.
+ */
+export function detectSource(
+  asset: CameraAsset,
+  hint?: MediaSource
+): MediaSource {
+  const explicit = (asset as { source?: unknown }).source;
+  if (explicit === 'gallery' || explicit === 'camera') return explicit;
+  if (hint) return hint;
+  const originalUri = (asset as { originalUri?: string }).originalUri;
+  return originalUri && originalUri.length > 0 ? 'gallery' : 'camera';
+}
+
+/**
+ * Builds a `MediaRecordInput` from a UI asset, storing the FINAL Documents path.
+ *
+ * @param source optional origin hint; when omitted the origin is auto-detected
+ *   (gallery vs camera). The stored `filePath` is always the resolved Documents
+ *   path — callers must only pass assets for which {@link isPublishedToDocuments}
+ *   is true (the repository enforces this).
+ */
+export function assetToRecordInput(
+  asset: CameraAsset,
+  source?: MediaSource
+): MediaRecordInput {
+  // Classify from every available signal (type + MIME + extension) so a picked
+  // document/audio file is stored under its true kind, never collapsed to image.
+  const mediaType = classifyMediaType(asset);
+  const now = Date.now();
+  // Persist the Documents path only. Fall back to uri defensively; the
+  // repository will have already filtered out un-published assets.
+  const documentsPath = resolveDocumentsPath(asset) ?? asset.uri ?? '';
+  return {
+    id: asset.id,
+    mediaType,
+    source: detectSource(asset, source),
+    filePath: documentsPath,
+    fileName:
+      asset.fileName ??
+      (mediaType === 'video'
+        ? `video_${now}.mp4`
+        : `photo_${now}.${extensionForMimeType(asset.mimeType, 'jpg')}`),
+    fileSize: asset.size ?? null,
+    width: asset.width ?? null,
+    height: asset.height ?? null,
+    // Videos and audio carry a duration; images/documents do not.
+    duration:
+      mediaType === 'video' || mediaType === 'audio'
+        ? asset.duration ?? null
+        : null,
+    mimeType: asset.mimeType ?? null,
+    createdAt: asset.dateTaken ?? now,
+    updatedAt: now,
+    // A compressed video quotes a proportional display size, not its bytes on
+    // disk; persist the flag so the preview / Info panel keeps that figure.
+    sizeIsDisplayEstimate: asset.sizeIsDisplayEstimate ?? null,
+  };
+}
+
+/** Normalizes a raw stored media_type string onto the {@link MediaType} enum. */
+function normalizeMediaType(value: unknown): MediaType {
+  return value === 'video' || value === 'document' || value === 'audio'
+    ? value
+    : 'image';
+}
+
+/** Maps a raw SQL row (snake_case columns) into a typed `MediaRecord`. */
+export function rowToRecord(row: Record<string, any>): MediaRecord {
+  return {
+    id: String(row[MediaColumns.id]),
+    mediaType: normalizeMediaType(row[MediaColumns.mediaType]),
+    source: normalizeSource(row[MediaColumns.source]),
+    filePath: row[MediaColumns.filePath] ?? '',
+    fileName: row[MediaColumns.fileName] ?? '',
+    fileSize: toNumberOrNull(row[MediaColumns.fileSize]),
+    width: toNumberOrNull(row[MediaColumns.width]),
+    height: toNumberOrNull(row[MediaColumns.height]),
+    duration: toNumberOrNull(row[MediaColumns.duration]),
+    mimeType: row[MediaColumns.mimeType] ?? null,
+    createdAt: Number(row[MediaColumns.createdAt]) || 0,
+    updatedAt: Number(row[MediaColumns.updatedAt]) || 0,
+    sizeIsDisplayEstimate: toBoolean(row[MediaColumns.sizeIsDisplayEstimate]),
+  };
+}
+
+/**
+ * Maps a persisted record back to the UI `CameraAsset` shape so the existing
+ * Media Library renders identically — only the data source changed.
+ */
+export function recordToAsset(record: MediaRecord): CameraAsset {
+  return {
+    id: record.id,
+    uri: record.filePath,
+    type: mediaTypeToAssetType(record.mediaType),
+    fileName: record.fileName,
+    mimeType: record.mimeType ?? undefined,
+    width: record.width ?? undefined,
+    height: record.height ?? undefined,
+    duration: record.duration ?? undefined,
+    size: record.fileSize ?? undefined,
+    dateTaken: record.createdAt,
+    needsThumbnail: record.mediaType === 'video',
+    sizeIsDisplayEstimate: record.sizeIsDisplayEstimate,
+  };
+}
+
+function toNumberOrNull(value: unknown): number | null {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * Coerces a stored INTEGER flag (1/0), or a driver-native boolean, to a boolean.
+ * A null/absent column (legacy rows predating the column) reads as false.
+ */
+function toBoolean(value: unknown): boolean {
+  if (value === null || value === undefined || value === '') return false;
+  if (typeof value === 'boolean') return value;
+  return Number(value) === 1;
+}

package/src/db/MediaRepository.ts

@@ -0,0 +1,313 @@
+/**
+ * MediaRepository — the CRUD/service layer over the `media` table.
+ *
+ * This is the ONLY module that writes SQL for media rows. UI code and hooks talk
+ * to strongly-typed `MediaRecord`/`CameraAsset` objects and never see a query
+ * string, keeping a clean separation between presentation and persistence.
+ *
+ * All operations delegate raw execution to the centralized `DatabaseManager`.
+ */
+import type { CameraAsset } from '../types';
+import {
+  getDatabaseManager,
+  type BatchStatement,
+  type DatabaseManager,
+} from './DatabaseManager';
+import {
+  assetToRecordInput,
+  isPublishedToDocuments,
+  recordToAsset,
+  rowToRecord,
+} from './MediaMapper';
+import {
+  MEDIA_TABLE,
+  MediaColumns as C,
+  type MediaCounts,
+  type MediaFilter,
+  type MediaQueryOptions,
+  type MediaRecord,
+  type MediaRecordInput,
+  type MediaSource,
+} from './types';
+
+const ALL_COLUMNS = [
+  C.id,
+  C.mediaType,
+  C.source,
+  C.filePath,
+  C.fileName,
+  C.fileSize,
+  C.width,
+  C.height,
+  C.duration,
+  C.mimeType,
+  C.createdAt,
+  C.updatedAt,
+  C.sizeIsDisplayEstimate,
+].join(', ');
+
+export class MediaRepository {
+  constructor(private readonly db: DatabaseManager = getDatabaseManager()) {}
+
+  /** Builds an idempotent UPSERT statement for one record. */
+  private upsertStatement(input: MediaRecordInput): BatchStatement {
+    const now = Date.now();
+    const createdAt = input.createdAt ?? now;
+    const updatedAt = input.updatedAt ?? now;
+    return {
+      sql: `INSERT INTO ${MEDIA_TABLE} (
+          ${ALL_COLUMNS}
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(${C.id}) DO UPDATE SET
+          ${C.mediaType} = excluded.${C.mediaType},
+          ${C.source}    = excluded.${C.source},
+          ${C.filePath}  = excluded.${C.filePath},
+          ${C.fileName}  = excluded.${C.fileName},
+          ${C.fileSize}  = excluded.${C.fileSize},
+          ${C.width}     = excluded.${C.width},
+          ${C.height}    = excluded.${C.height},
+          ${C.duration}  = excluded.${C.duration},
+          ${C.mimeType}  = excluded.${C.mimeType},
+          ${C.sizeIsDisplayEstimate} = excluded.${C.sizeIsDisplayEstimate},
+          ${C.updatedAt} = excluded.${C.updatedAt};`,
+      params: [
+        input.id,
+        input.mediaType,
+        input.source,
+        input.filePath,
+        input.fileName,
+        input.fileSize ?? null,
+        input.width ?? null,
+        input.height ?? null,
+        input.duration ?? null,
+        input.mimeType ?? null,
+        createdAt,
+        updatedAt,
+        input.sizeIsDisplayEstimate == null
+          ? null
+          : input.sizeIsDisplayEstimate
+            ? 1
+            : 0,
+      ],
+    };
+  }
+
+  /** Inserts (or updates on id/path conflict) a single record. */
+  async insert(input: MediaRecordInput): Promise<void> {
+    const stmt = this.upsertStatement(input);
+    await this.db.exec(stmt.sql, stmt.params);
+  }
+
+  /** Inserts many records atomically in one transaction. */
+  async insertMany(inputs: MediaRecordInput[]): Promise<void> {
+    if (inputs.length === 0) return;
+    await this.db.batch(inputs.map((i) => this.upsertStatement(i)));
+  }
+
+  /**
+   * Persists confirmed, Documents-backed media from the capture/gallery Send
+   * flows. This is the ONLY path the app uses after a successful Send.
+   *
+   * Contract enforced here (so callers can't create inconsistent records):
+   *   1. Only assets that have been successfully moved to the Documents
+   *      directory are persisted — see {@link isPublishedToDocuments}. A
+   *      cache-only or publish-failed asset is skipped, never stored.
+   *   2. The stored `filePath` is always the final Documents path, never cache.
+   *   3. The write is atomic; on failure nothing is committed (all-or-nothing),
+   *      so a partial batch can't leave dangling rows.
+   *
+   * @param source optional origin hint; when omitted, each asset's origin is
+   *   auto-detected (gallery vs camera).
+   * @returns the records actually persisted (may be fewer than `assets`).
+   */
+  async insertAssets(
+    assets: CameraAsset[],
+    source?: MediaSource
+  ): Promise<MediaRecord[]> {
+    // Gate: keep only well-formed assets that are confirmed in Documents.
+    const publishable = assets.filter(
+      (a) => a && a.id && a.uri && isPublishedToDocuments(a)
+    );
+
+    const skipped = assets.length - publishable.length;
+    if (skipped > 0) {
+      console.warn(
+        `[MediaRepository] Skipped ${skipped} asset(s) not yet in the ` +
+          `Documents directory; they will not be persisted.`
+      );
+    }
+
+    if (publishable.length === 0) return [];
+
+    const inputs = publishable.map((a) => assetToRecordInput(a, source));
+
+    // Atomic insert. If it throws, the transaction rolls back and we surface the
+    // error to the caller without having written any partial state.
+    await this.insertMany(inputs);
+
+    return inputs.map((i) => ({
+      ...i,
+      fileSize: i.fileSize ?? null,
+      width: i.width ?? null,
+      height: i.height ?? null,
+      duration: i.duration ?? null,
+      mimeType: i.mimeType ?? null,
+      createdAt: i.createdAt ?? Date.now(),
+      updatedAt: i.updatedAt ?? Date.now(),
+      sizeIsDisplayEstimate: i.sizeIsDisplayEstimate ?? false,
+    }));
+  }
+
+  private buildWhere(filter?: MediaFilter): { clause: string; args: any[] } {
+    if (
+      filter === 'image' ||
+      filter === 'video' ||
+      filter === 'document' ||
+      filter === 'audio'
+    ) {
+      return { clause: `WHERE ${C.mediaType} = ?`, args: [filter] };
+    }
+    return { clause: '', args: [] };
+  }
+
+  /** Returns records matching the query, newest first by default. */
+  async getAll(options: MediaQueryOptions = {}): Promise<MediaRecord[]> {
+    const {
+      filter = 'all',
+      orderBy = 'createdAt',
+      direction = 'DESC',
+      limit,
+      offset,
+    } = options;
+
+    const orderColumn =
+      orderBy === 'updatedAt'
+        ? C.updatedAt
+        : orderBy === 'fileName'
+          ? C.fileName
+          : C.createdAt;
+    const dir = direction === 'ASC' ? 'ASC' : 'DESC';
+    const { clause, args } = this.buildWhere(filter);
+
+    let sql = `SELECT ${ALL_COLUMNS} FROM ${MEDIA_TABLE} ${clause} ORDER BY ${orderColumn} ${dir}`;
+    const params = [...args];
+    if (typeof limit === 'number') {
+      sql += ' LIMIT ?';
+      params.push(limit);
+      if (typeof offset === 'number') {
+        sql += ' OFFSET ?';
+        params.push(offset);
+      }
+    }
+
+    const rows = await this.db.query<Record<string, any>>(sql, params);
+    return rows.map(rowToRecord);
+  }
+
+  /** Returns only image records (backs the "Photos" filter). */
+  getImages(options: Omit<MediaQueryOptions, 'filter'> = {}) {
+    return this.getAll({ ...options, filter: 'image' });
+  }
+
+  /** Returns only video records (backs the "Videos" filter). */
+  getVideos(options: Omit<MediaQueryOptions, 'filter'> = {}) {
+    return this.getAll({ ...options, filter: 'video' });
+  }
+
+  /** Returns records mapped straight to UI `CameraAsset`s. */
+  async getAssets(options: MediaQueryOptions = {}): Promise<CameraAsset[]> {
+    const records = await this.getAll(options);
+    return records.map(recordToAsset);
+  }
+
+  /** Fetches a single record by id, or null. */
+  async getById(id: string): Promise<MediaRecord | null> {
+    const rows = await this.db.query<Record<string, any>>(
+      `SELECT ${ALL_COLUMNS} FROM ${MEDIA_TABLE} WHERE ${C.id} = ? LIMIT 1`,
+      [id]
+    );
+    return rows.length > 0 ? rowToRecord(rows[0]!) : null;
+  }
+
+  /**
+   * Computes the filter-card counts directly from the database in one query,
+   * one bucket per media kind (image / video / document / audio).
+   */
+  async getCounts(): Promise<MediaCounts> {
+    const rows = await this.db.query<{ media_type: string; c: number }>(
+      `SELECT ${C.mediaType} AS ${C.mediaType}, COUNT(*) AS c
+         FROM ${MEDIA_TABLE} GROUP BY ${C.mediaType}`
+    );
+    const counts: MediaCounts = {
+      all: 0,
+      image: 0,
+      video: 0,
+      document: 0,
+      audio: 0,
+    };
+    for (const row of rows) {
+      const c = Number(row.c) || 0;
+      switch (row.media_type) {
+        case 'video':
+          counts.video += c;
+          break;
+        case 'document':
+          counts.document += c;
+          break;
+        case 'audio':
+          counts.audio += c;
+          break;
+        default:
+          counts.image += c;
+          break;
+      }
+      counts.all += c;
+    }
+    return counts;
+  }
+
+  /** Deletes a record by id. Returns true if a row was removed. */
+  async deleteById(id: string): Promise<boolean> {
+    const result = await this.db.exec(
+      `DELETE FROM ${MEDIA_TABLE} WHERE ${C.id} = ?`,
+      [id]
+    );
+    return result.rowsAffected > 0;
+  }
+
+  /** Deletes a record by its file path/URI. Returns true if a row was removed. */
+  async deleteByPath(filePath: string): Promise<boolean> {
+    const result = await this.db.exec(
+      `DELETE FROM ${MEDIA_TABLE} WHERE ${C.filePath} = ?`,
+      [filePath]
+    );
+    return result.rowsAffected > 0;
+  }
+
+  /** Deletes multiple records by id atomically. Returns the number requested. */
+  async deleteMany(ids: string[]): Promise<void> {
+    if (ids.length === 0) return;
+    await this.db.batch(
+      ids.map((id) => ({
+        sql: `DELETE FROM ${MEDIA_TABLE} WHERE ${C.id} = ?`,
+        params: [id],
+      }))
+    );
+  }
+
+  /** Removes every media row. */
+  async clear(): Promise<void> {
+    await this.db.exec(`DELETE FROM ${MEDIA_TABLE}`);
+  }
+}
+
+// Shared singleton repository over the singleton manager.
+let repositoryInstance: MediaRepository | null = null;
+
+/** Returns the shared `MediaRepository` singleton. */
+export function getMediaRepository(): MediaRepository {
+  if (!repositoryInstance) {
+    repositoryInstance = new MediaRepository();
+  }
+  return repositoryInstance;
+}