sqlite local

mobile/services/db/repositories/folders.ts

@@ -1,69 +1,129 @@
 import { getDatabase } from '../client';
+import { newResourceId } from '../id';
 import { FOLDER_COLUMNS_SQL } from '../schema';
-import type { Folder, FolderContext, FolderRow, SyncStatus } from '../types';
+import { getDeviceUserId } from './preferences';
+import type { FolderRow, StoredFolder, SyncStatus } from '../types';
 
-type SaveFolderOptions = {
-  parentUri?: string;
+export type SaveFolderInput = {
+  uri: string | null;
+  name: string;
+  exists?: boolean;
+  resource_id?: string;
+};
+
+export type SaveFolderOptions = {
+  parentResourceId?: string | null;
   syncStatus?: SyncStatus;
 };
 
 export async function saveFolder(
-  folder: Folder,
-  options?: SaveFolderOptions,
-): Promise<void> {
+  input: SaveFolderInput,
+  options: SaveFolderOptions = {},
+): Promise<StoredFolder> {
   const db = await getDatabase();
-  const exists = folder.exists === undefined ? null : folder.exists ? 1 : 0;
+  const now = Date.now();
+  const exists =
+    input.exists === undefined || input.exists === null ? null : input.exists ? 1 : 0;
+  const ownerId = await getDeviceUserId();
+
+  const existing = input.uri
+    ? await db.getFirstAsync<FolderRow>(
+        `SELECT ${FOLDER_COLUMNS_SQL} FROM folders WHERE uri = ?`,
+        input.uri,
+      )
+    : input.resource_id
+      ? await db.getFirstAsync<FolderRow>(
+          `SELECT ${FOLDER_COLUMNS_SQL} FROM folders WHERE resource_id = ?`,
+          input.resource_id,
+        )
+      : null;
+
+  const resourceId = existing?.resource_id ?? input.resource_id ?? (await newResourceId());
+  const baseSync = existing?.sync_status ?? options.syncStatus ?? 'local';
 
   await db.runAsync(
-    `INSERT INTO folders (uri, name, "exists", sync_status, added_at, parent_uri)
-     VALUES (?, ?, ?, ?, ?, ?)
-     ON CONFLICT(uri) DO UPDATE SET
-       name = excluded.name, "exists" = excluded."exists", sync_status = excluded.sync_status`,
-    folder.uri,
-    folder.name,
+    `INSERT INTO folders
+       (resource_id, uri, name, "exists", parent_resource_id, owner_id, sync_status, added_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(resource_id) DO UPDATE SET
+       uri = excluded.uri,
+       name = excluded.name,
+       "exists" = excluded."exists",
+       parent_resource_id = CASE
+         WHEN excluded.parent_resource_id IS NULL THEN folders.parent_resource_id
+         ELSE excluded.parent_resource_id
+       END,
+       sync_status = excluded.sync_status,
+       updated_at = excluded.updated_at`,
+    resourceId,
+    input.uri,
+    input.name,
     exists,
-    options?.syncStatus ?? 'local',
-    Date.now(),
-    options?.parentUri ?? null,
+    options.parentResourceId ?? null,
+    ownerId,
+    baseSync,
+    existing?.added_at ?? now,
+    now,
   );
+
+  const row = await db.getFirstAsync<FolderRow>(
+    `SELECT ${FOLDER_COLUMNS_SQL} FROM folders WHERE resource_id = ?`,
+    resourceId,
+  );
+  return toStoredFolder(row!);
 }
 
-export async function saveDirectory(folder: Folder): Promise<boolean> {
-  await saveFolder(folder);
-  return true;
+export async function saveDirectory(folder: {
+  uri: string;
+  name: string;
+  exists?: boolean;
+}): Promise<StoredFolder> {
+  return saveFolder({ uri: folder.uri, name: folder.name, exists: folder.exists });
 }
 
-export async function getFolders(): Promise<FolderContext[]> {
+export async function getFolders(): Promise<StoredFolder[]> {
   const db = await getDatabase();
   const rows = await db.getAllAsync<FolderRow>(
-    `SELECT ${FOLDER_COLUMNS_SQL} FROM folders ORDER BY added_at ASC, name ASC`,
+    `SELECT ${FOLDER_COLUMNS_SQL} FROM folders ORDER BY name ASC`,
   );
-  return rows.map(toFolderContext);
+  return rows.map(toStoredFolder);
 }
 
-export async function getFolderFolders(parentUri: string): Promise<FolderContext[]> {
+export async function getFolderFolders(
+  parentResourceId: string | null,
+): Promise<StoredFolder[]> {
   const db = await getDatabase();
   const rows = await db.getAllAsync<FolderRow>(
-    `SELECT ${FOLDER_COLUMNS_SQL} FROM folders WHERE parent_uri = ? ORDER BY name ASC`,
-    parentUri,
+    `SELECT ${FOLDER_COLUMNS_SQL} FROM folders WHERE parent_resource_id IS ? ORDER BY name ASC`,
+    parentResourceId,
   );
-  return rows.map(toFolderContext);
+  return rows.map(toStoredFolder);
 }
 
-export async function removeFolder(uri: string): Promise<void> {
+export async function getFolder(resourceId: string): Promise<StoredFolder | null> {
   const db = await getDatabase();
-  await db.runAsync('DELETE FROM folders WHERE uri = ?', uri);
+  const row = await db.getFirstAsync<FolderRow>(
+    `SELECT ${FOLDER_COLUMNS_SQL} FROM folders WHERE resource_id = ?`,
+    resourceId,
+  );
+  return row ? toStoredFolder(row) : null;
 }
 
-function toFolderContext(row: FolderRow): FolderContext {
+export async function removeFolder(resourceId: string): Promise<void> {
+  const db = await getDatabase();
+  await db.runAsync('DELETE FROM folders WHERE resource_id = ?', resourceId);
+}
+
+function toStoredFolder(row: FolderRow): StoredFolder {
   return {
+    resource_id: row.resource_id,
+    uri: row.uri,
+    name: row.name,
+    exists: row.exists === 1,
+    parent_resource_id: row.parent_resource_id,
+    owner_id: row.owner_id,
     syncStatus: row.sync_status,
     addedAt: row.added_at,
-    folder: {
-      uri: row.uri,
-      name: row.name,
-      isDirectory: true,
-      exists: row.exists === null ? undefined : row.exists === 1,
-    },
+    updatedAt: row.updated_at,
   };
 }