Merge pull request #20 from kmc7468/dev

v0.9.0

src/lib/components/atoms/Chip.svelte

@@ -9,8 +9,8 @@
     class?: ClassValue;
     onclick?: () => void;
     onRemoveClick?: () => void;
-    selected?: boolean;
     removable?: boolean;
+    selected?: boolean;
   }
 
   let {
@@ -38,7 +38,7 @@
   <span>
     {@render children()}
   </span>
-  {#if selected && removable}
+  {#if removable && selected}
     <button
       onclick={(e) => {
         e.stopPropagation();

src/lib/components/atoms/buttons/FileThumbnailButton.svelte

@@ -24,10 +24,10 @@
     <div class="h-full w-full bg-gray-100"></div>
   {/if}
   {#if info.isFavorite}
-    <div class={["absolute bottom-0 right-0", !thumbnail && "rounded-full bg-white p-0.5"]}>
+    <div class={["absolute bottom-0.5 right-0.5"]}>
       <IconFavorite
         class="text-sm text-red-500"
-        style="filter: drop-shadow(0 0 1px white) drop-shadow(0 0 1px white);"
+        style="filter: drop-shadow(0 0 1px white) drop-shadow(0 0 1px white)"
       />
     </div>
   {/if}

src/lib/components/molecules/TopBar.svelte

@@ -25,9 +25,9 @@
     {#if showBackButton}
       <button
         onclick={onBackClick ?? (() => history.back())}
-        class="w-[2.3rem] flex-shrink-0 rounded-full p-1 active:bg-black active:bg-opacity-[0.04]"
+        class="w-full rounded-full p-1 text-2xl active:bg-black active:bg-opacity-[0.04]"
       >
-        <IconArrowBack class="text-2xl" />
+        <IconArrowBack />
       </button>
     {/if}
   </div>

src/lib/components/molecules/labels/DirectoryEntryLabel.svelte

@@ -43,7 +43,7 @@
       <div class={["absolute bottom-0 right-0", !thumbnail && "rounded-full bg-white p-0.5"]}>
         <IconFavorite
           class="text-xs text-red-500"
-          style="filter: drop-shadow(0 0 1px white) drop-shadow(0 0 1px white);"
+          style="filter: drop-shadow(0 0 1px white) drop-shadow(0 0 1px white)"
         />
       </div>
     {/if}

src/lib/indexedDB/cacheIndex.ts

@@ -20,7 +20,12 @@ export const getFileCacheIndex = async () => {
 };
 
 export const storeFileCacheIndex = async (fileCacheIndex: FileCacheIndex) => {
-  await cacheIndex.fileCache.put(fileCacheIndex);
+  await cacheIndex.fileCache.put({
+    fileId: fileCacheIndex.fileId,
+    cachedAt: fileCacheIndex.cachedAt,
+    lastRetrievedAt: fileCacheIndex.lastRetrievedAt,
+    size: fileCacheIndex.size,
+  });
 };
 
 export const deleteFileCacheIndex = async (fileId: number) => {

src/lib/indexedDB/filesystem.ts

@@ -4,7 +4,7 @@ interface DirectoryInfo {
   id: number;
   parentId: DirectoryId;
   name: string;
-  isFavorite?: boolean;
+  isFavorite: boolean;
 }
 
 interface FileInfo {
@@ -15,7 +15,7 @@ interface FileInfo {
   createdAt?: Date;
   lastModifiedAt: Date;
   categoryIds?: number[];
-  isFavorite?: boolean;
+  isFavorite: boolean;
 }
 
 interface CategoryInfo {
@@ -48,6 +48,23 @@ filesystem
       });
   });
 
+filesystem.version(4).upgrade(async (trx) => {
+  await Promise.all([
+    trx
+      .table("directory")
+      .toCollection()
+      .modify((directory) => {
+        directory.isFavorite = false;
+      }),
+    trx
+      .table("file")
+      .toCollection()
+      .modify((file) => {
+        file.isFavorite = false;
+      }),
+  ]);
+});
+
 export const getDirectoryInfos = async (parentId: DirectoryId) => {
   return await filesystem.directory.where({ parentId }).toArray();
 };
@@ -57,7 +74,11 @@ export const getDirectoryInfo = async (id: number) => {
 };
 
 export const storeDirectoryInfo = async (directoryInfo: DirectoryInfo) => {
-  await filesystem.directory.upsert(directoryInfo.id, { ...directoryInfo });
+  await filesystem.directory.upsert(directoryInfo.id, {
+    parentId: directoryInfo.parentId,
+    name: directoryInfo.name,
+    isFavorite: directoryInfo.isFavorite,
+  });
 };
 
 export const deleteDirectoryInfo = async (id: number) => {
@@ -91,7 +112,15 @@ export const bulkGetFileInfos = async (ids: number[]) => {
 };
 
 export const storeFileInfo = async (fileInfo: FileInfo) => {
-  await filesystem.file.upsert(fileInfo.id, { ...fileInfo });
+  await filesystem.file.upsert(fileInfo.id, {
+    parentId: fileInfo.parentId,
+    name: fileInfo.name,
+    contentType: fileInfo.contentType,
+    createdAt: fileInfo.createdAt,
+    lastModifiedAt: fileInfo.lastModifiedAt,
+    categoryIds: fileInfo.categoryIds,
+    isFavorite: fileInfo.isFavorite,
+  });
 };
 
 export const deleteFileInfo = async (id: number) => {
@@ -118,7 +147,12 @@ export const getCategoryInfo = async (id: number) => {
 };
 
 export const storeCategoryInfo = async (categoryInfo: CategoryInfo) => {
-  await filesystem.category.upsert(categoryInfo.id, { ...categoryInfo });
+  await filesystem.category.upsert(categoryInfo.id, {
+    parentId: categoryInfo.parentId,
+    name: categoryInfo.name,
+    files: categoryInfo.files,
+    isFileRecursive: categoryInfo.isFileRecursive,
+  });
 };
 
 export const updateCategoryInfo = async (id: number, changes: { isFileRecursive?: boolean }) => {

src/lib/modules/filesystem/category.ts

@@ -1,7 +1,6 @@
 import * as IndexedDB from "$lib/indexedDB";
 import { trpc, isTRPCClientError } from "$trpc/client";
-import { decryptFileMetadata, decryptCategoryMetadata } from "./common";
-import { FilesystemCache } from "./FilesystemCache.svelte";
+import { FilesystemCache, decryptFileMetadata, decryptCategoryMetadata } from "./internal.svelte";
 import type { CategoryInfo, MaybeCategoryInfo } from "./types";
 
 const cache = new FilesystemCache<CategoryId, MaybeCategoryInfo>({
@@ -66,8 +65,8 @@ const cache = new FilesystemCache<CategoryId, MaybeCategoryInfo>({
               id: file.id,
               parentId: file.parent,
               contentType: file.contentType,
-              isRecursive: file.isRecursive,
               isFavorite: file.isFavorite,
+              isRecursive: file.isRecursive,
               ...(await decryptFileMetadata(file, masterKey)),
             })),
           ),

src/lib/modules/filesystem/common.ts

@@ -1,50 +0,0 @@
-import { unwrapDataKey, decryptString } from "$lib/modules/crypto";
-
-export const decryptDirectoryMetadata = async (
-  metadata: { dek: string; dekVersion: Date; name: string; nameIv: string },
-  masterKey: CryptoKey,
-) => {
-  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
-  const name = await decryptString(metadata.name, metadata.nameIv, dataKey);
-
-  return {
-    dataKey: { key: dataKey, version: metadata.dekVersion },
-    name,
-  };
-};
-
-const decryptDate = async (ciphertext: string, iv: string, dataKey: CryptoKey) => {
-  return new Date(parseInt(await decryptString(ciphertext, iv, dataKey), 10));
-};
-
-export const decryptFileMetadata = async (
-  metadata: {
-    dek: string;
-    dekVersion: Date;
-    name: string;
-    nameIv: string;
-    createdAt?: string;
-    createdAtIv?: string;
-    lastModifiedAt: string;
-    lastModifiedAtIv: string;
-  },
-  masterKey: CryptoKey,
-) => {
-  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
-  const [name, createdAt, lastModifiedAt] = await Promise.all([
-    decryptString(metadata.name, metadata.nameIv, dataKey),
-    metadata.createdAt
-      ? decryptDate(metadata.createdAt, metadata.createdAtIv!, dataKey)
-      : undefined,
-    decryptDate(metadata.lastModifiedAt, metadata.lastModifiedAtIv, dataKey),
-  ]);
-
-  return {
-    dataKey: { key: dataKey, version: metadata.dekVersion },
-    name,
-    createdAt,
-    lastModifiedAt,
-  };
-};
-
-export const decryptCategoryMetadata = decryptDirectoryMetadata;

src/lib/modules/filesystem/directory.ts

@@ -1,7 +1,6 @@
 import * as IndexedDB from "$lib/indexedDB";
 import { trpc, isTRPCClientError } from "$trpc/client";
-import { decryptDirectoryMetadata, decryptFileMetadata } from "./common";
-import { FilesystemCache, type FilesystemCacheOptions } from "./FilesystemCache.svelte";
+import { FilesystemCache, decryptDirectoryMetadata, decryptFileMetadata } from "./internal.svelte";
 import type { DirectoryInfo, MaybeDirectoryInfo } from "./types";
 
 const cache = new FilesystemCache<DirectoryId, MaybeDirectoryInfo>({
@@ -27,6 +26,7 @@ const cache = new FilesystemCache<DirectoryId, MaybeDirectoryInfo>({
         name: directory.name,
         subDirectories,
         files,
+        isFavorite: directory.isFavorite,
       };
     }
   },
@@ -62,6 +62,7 @@ const cache = new FilesystemCache<DirectoryId, MaybeDirectoryInfo>({
               parentId: directory.metadata!.parent,
               subDirectories,
               files,
+              isFavorite: directory.metadata!.isFavorite,
               ...metadata!,
             }
           : { id, subDirectories, files },
@@ -104,8 +105,30 @@ export const getDirectoryInfo = (
   id: DirectoryId,
   masterKey: CryptoKey,
   options?: {
-    fetchFromServer?: FilesystemCacheOptions<DirectoryId, MaybeDirectoryInfo>["fetchFromServer"];
+    serverResponse?: {
+      parent: DirectoryId;
+      dek: string;
+      dekVersion: Date;
+      name: string;
+      nameIv: string;
+      isFavorite: boolean;
+    };
   },
 ) => {
-  return cache.get(id, masterKey, options);
+  return cache.get(id, masterKey, {
+    fetchFromServer:
+      options?.serverResponse &&
+      (async (cachedValue) => {
+        const metadata = await decryptDirectoryMetadata(options!.serverResponse!, masterKey);
+        return storeToIndexedDB({
+          subDirectories: [],
+          files: [],
+          ...cachedValue,
+          id: id as number,
+          parentId: options!.serverResponse!.parent,
+          isFavorite: options!.serverResponse!.isFavorite,
+          ...metadata,
+        });
+      }),
+  });
 };

src/lib/modules/filesystem/file.ts

@@ -1,7 +1,6 @@
 import * as IndexedDB from "$lib/indexedDB";
 import { trpc, isTRPCClientError } from "$trpc/client";
-import { decryptFileMetadata, decryptCategoryMetadata } from "./common";
-import { FilesystemCache, type FilesystemCacheOptions } from "./FilesystemCache.svelte";
+import { FilesystemCache, decryptFileMetadata, decryptCategoryMetadata } from "./internal.svelte";
 import type { FileInfo, MaybeFileInfo } from "./types";
 
 const cache = new FilesystemCache<number, MaybeFileInfo>({
@@ -27,8 +26,8 @@ const cache = new FilesystemCache<number, MaybeFileInfo>({
         name: file.name,
         createdAt: file.createdAt,
         lastModifiedAt: file.lastModifiedAt,
-        isFavorite: file.isFavorite,
         categories: categories?.filter((category) => !!category) ?? [],
+        isFavorite: file.isFavorite,
       };
     }
   },
@@ -56,8 +55,8 @@ const cache = new FilesystemCache<number, MaybeFileInfo>({
         name: metadata.name,
         createdAt: metadata.createdAt,
         lastModifiedAt: metadata.lastModifiedAt,
-        isFavorite: file.isFavorite,
         categories,
+        isFavorite: file.isFavorite,
       });
     } catch (e) {
       if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
@@ -175,9 +174,38 @@ const bulkStoreToIndexedDB = (infos: FileInfo[]) => {
 export const getFileInfo = (
   id: number,
   masterKey: CryptoKey,
-  options?: { fetchFromServer?: FilesystemCacheOptions<number, MaybeFileInfo>["fetchFromServer"] },
+  options?: {
+    serverResponse?: {
+      parent: DirectoryId;
+      dek: string;
+      dekVersion: Date;
+      contentType: string;
+      name: string;
+      nameIv: string;
+      createdAt?: string;
+      createdAtIv?: string;
+      lastModifiedAt: string;
+      lastModifiedAtIv: string;
+      isFavorite: boolean;
+    };
+  },
 ) => {
-  return cache.get(id, masterKey, options);
+  return cache.get(id, masterKey, {
+    fetchFromServer:
+      options?.serverResponse &&
+      (async (cachedValue) => {
+        const metadata = await decryptFileMetadata(options!.serverResponse!, masterKey);
+        return storeToIndexedDB({
+          categories: [],
+          ...cachedValue,
+          id,
+          parentId: options!.serverResponse!.parent,
+          contentType: options!.serverResponse!.contentType,
+          isFavorite: options!.serverResponse!.isFavorite,
+          ...metadata,
+        });
+      }),
+  });
 };
 
 export const bulkGetFileInfo = (ids: number[], masterKey: CryptoKey) => {

src/lib/modules/filesystem/index.ts

@@ -1,5 +1,4 @@
 export * from "./category";
-export * from "./common";
 export * from "./directory";
 export * from "./file";
 export * from "./types";

src/lib/modules/filesystem/internal.svelte.ts

@@ -1,6 +1,7 @@
 import { untrack } from "svelte";
+import { unwrapDataKey, decryptString } from "$lib/modules/crypto";
 
-export interface FilesystemCacheOptions<K, V> {
+interface FilesystemCacheOptions<K, V> {
   fetchFromIndexedDB: (key: K) => Promise<V | undefined>;
   fetchFromServer: (key: K, cachedValue: V | undefined, masterKey: CryptoKey) => Promise<V>;
   bulkFetchFromIndexedDB?: (keys: Set<K>) => Promise<Map<K, V>>;
@@ -18,7 +19,7 @@ export class FilesystemCache<K, V extends object> {
   get(
     key: K,
     masterKey: CryptoKey,
-    options?: { fetchFromServer?: FilesystemCacheOptions<K, V>["fetchFromServer"] },
+    options?: { fetchFromServer?: (cachedValue: V | undefined) => Promise<V> },
   ) {
     return untrack(() => {
       let state = this.map.get(key);
@@ -42,8 +43,10 @@ export class FilesystemCache<K, V extends object> {
             return loadedInfo;
           })
       )
-        .then((cachedInfo) =>
-          (options?.fetchFromServer ?? this.options.fetchFromServer)(key, cachedInfo, masterKey),
+        .then(
+          (cachedInfo) =>
+            options?.fetchFromServer?.(cachedInfo) ??
+            this.options.fetchFromServer(key, cachedInfo, masterKey),
         )
         .then((loadedInfo) => {
           if (state.value) {
@@ -126,3 +129,52 @@ export class FilesystemCache<K, V extends object> {
     });
   }
 }
+
+export const decryptDirectoryMetadata = async (
+  metadata: { dek: string; dekVersion: Date; name: string; nameIv: string },
+  masterKey: CryptoKey,
+) => {
+  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
+  const name = await decryptString(metadata.name, metadata.nameIv, dataKey);
+
+  return {
+    dataKey: { key: dataKey, version: metadata.dekVersion },
+    name,
+  };
+};
+
+const decryptDate = async (ciphertext: string, iv: string, dataKey: CryptoKey) => {
+  return new Date(parseInt(await decryptString(ciphertext, iv, dataKey), 10));
+};
+
+export const decryptFileMetadata = async (
+  metadata: {
+    dek: string;
+    dekVersion: Date;
+    name: string;
+    nameIv: string;
+    createdAt?: string;
+    createdAtIv?: string;
+    lastModifiedAt: string;
+    lastModifiedAtIv: string;
+  },
+  masterKey: CryptoKey,
+) => {
+  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
+  const [name, createdAt, lastModifiedAt] = await Promise.all([
+    decryptString(metadata.name, metadata.nameIv, dataKey),
+    metadata.createdAt
+      ? decryptDate(metadata.createdAt, metadata.createdAtIv!, dataKey)
+      : undefined,
+    decryptDate(metadata.lastModifiedAt, metadata.lastModifiedAtIv, dataKey),
+  ]);
+
+  return {
+    dataKey: { key: dataKey, version: metadata.dekVersion },
+    name,
+    createdAt,
+    lastModifiedAt,
+  };
+};
+
+export const decryptCategoryMetadata = decryptDirectoryMetadata;

src/lib/modules/filesystem/types.ts

@@ -1,14 +1,13 @@
 export type DataKey = { key: CryptoKey; version: Date };
-type AllUndefined<T> = { [K in keyof T]?: undefined };
 
 export interface LocalDirectoryInfo {
   id: number;
   parentId: DirectoryId;
   dataKey?: DataKey;
   name: string;
-  isFavorite?: boolean;
   subDirectories: SubDirectoryInfo[];
   files: SummarizedFileInfo[];
+  isFavorite: boolean;
 }
 
 export interface RootDirectoryInfo {
@@ -18,6 +17,7 @@ export interface RootDirectoryInfo {
   name?: undefined;
   subDirectories: SubDirectoryInfo[];
   files: SummarizedFileInfo[];
+  isFavorite?: undefined;
 }
 
 export type DirectoryInfo = LocalDirectoryInfo | RootDirectoryInfo;
@@ -37,7 +37,7 @@ export interface FileInfo {
   createdAt?: Date;
   lastModifiedAt: Date;
   categories: FileCategoryInfo[];
-  isFavorite?: boolean;
+  isFavorite: boolean;
 }
 
 export type MaybeFileInfo =

src/lib/server/db/directory.ts

@@ -0,0 +1,245 @@
+import type { Selectable } from "kysely";
+import { IntegrityError } from "./error";
+import db from "./kysely";
+import type { Ciphertext, DirectoryTable } from "./schema";
+
+interface Directory {
+  id: number;
+  parentId: DirectoryId;
+  userId: number;
+  mekVersion: number;
+  encDek: string;
+  dekVersion: Date;
+  encName: Ciphertext;
+  isFavorite: boolean;
+}
+
+const toDirectory = (row: Selectable<DirectoryTable>): Directory => ({
+  id: row.id,
+  parentId: row.parent_id ?? "root",
+  userId: row.user_id,
+  mekVersion: row.master_encryption_key_version,
+  encDek: row.encrypted_data_encryption_key,
+  dekVersion: row.data_encryption_key_version,
+  encName: row.encrypted_name,
+  isFavorite: row.is_favorite,
+});
+
+export const registerDirectory = async (params: Omit<Directory, "id" | "isFavorite">) => {
+  await db.transaction().execute(async (trx) => {
+    const mek = await trx
+      .selectFrom("master_encryption_key")
+      .select("version")
+      .where("user_id", "=", params.userId)
+      .where("state", "=", "active")
+      .limit(1)
+      .forUpdate()
+      .executeTakeFirst();
+    if (mek?.version !== params.mekVersion) {
+      throw new IntegrityError("Inactive MEK version");
+    }
+
+    const { directoryId } = await trx
+      .insertInto("directory")
+      .values({
+        parent_id: params.parentId !== "root" ? params.parentId : null,
+        user_id: params.userId,
+        master_encryption_key_version: params.mekVersion,
+        encrypted_data_encryption_key: params.encDek,
+        data_encryption_key_version: params.dekVersion,
+        encrypted_name: params.encName,
+      })
+      .returning("id as directoryId")
+      .executeTakeFirstOrThrow();
+    await trx
+      .insertInto("directory_log")
+      .values({
+        directory_id: directoryId,
+        timestamp: new Date(),
+        action: "create",
+        new_name: params.encName,
+      })
+      .execute();
+  });
+};
+
+export const getAllDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
+  const directories = await db
+    .selectFrom("directory")
+    .selectAll()
+    .where("user_id", "=", userId)
+    .$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
+    .$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
+    .execute();
+  return directories.map(toDirectory);
+};
+
+export const getAllRecursiveDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
+  const directories = await db
+    .withRecursive("directory_tree", (db) =>
+      db
+        .selectFrom("directory")
+        .selectAll()
+        .$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
+        .$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
+        .where("user_id", "=", userId)
+        .unionAll((db) =>
+          db
+            .selectFrom("directory")
+            .innerJoin("directory_tree", "directory.parent_id", "directory_tree.id")
+            .selectAll("directory"),
+        ),
+    )
+    .selectFrom("directory_tree")
+    .selectAll()
+    .execute();
+  return directories.map(toDirectory);
+};
+
+export const getAllFavoriteDirectories = async (userId: number) => {
+  const directories = await db
+    .selectFrom("directory")
+    .selectAll()
+    .where("user_id", "=", userId)
+    .where("is_favorite", "=", true)
+    .execute();
+  return directories.map(toDirectory);
+};
+
+export const getDirectory = async (userId: number, directoryId: number) => {
+  const directory = await db
+    .selectFrom("directory")
+    .selectAll()
+    .where("id", "=", directoryId)
+    .where("user_id", "=", userId)
+    .limit(1)
+    .executeTakeFirst();
+  return directory ? toDirectory(directory) : null;
+};
+
+export const setDirectoryEncName = async (
+  userId: number,
+  directoryId: number,
+  dekVersion: Date,
+  encName: Ciphertext,
+) => {
+  await db.transaction().execute(async (trx) => {
+    const directory = await trx
+      .selectFrom("directory")
+      .select("data_encryption_key_version")
+      .where("id", "=", directoryId)
+      .where("user_id", "=", userId)
+      .limit(1)
+      .forUpdate()
+      .executeTakeFirst();
+    if (!directory) {
+      throw new IntegrityError("Directory not found");
+    } else if (directory.data_encryption_key_version.getTime() !== dekVersion.getTime()) {
+      throw new IntegrityError("Invalid DEK version");
+    }
+
+    await trx
+      .updateTable("directory")
+      .set({ encrypted_name: encName })
+      .where("id", "=", directoryId)
+      .where("user_id", "=", userId)
+      .execute();
+    await trx
+      .insertInto("directory_log")
+      .values({
+        directory_id: directoryId,
+        timestamp: new Date(),
+        action: "rename",
+        new_name: encName,
+      })
+      .execute();
+  });
+};
+
+export const setDirectoryFavorite = async (
+  userId: number,
+  directoryId: number,
+  isFavorite: boolean,
+) => {
+  await db.transaction().execute(async (trx) => {
+    const directory = await trx
+      .selectFrom("directory")
+      .select("is_favorite")
+      .where("id", "=", directoryId)
+      .where("user_id", "=", userId)
+      .limit(1)
+      .forUpdate()
+      .executeTakeFirst();
+    if (!directory) {
+      throw new IntegrityError("Directory not found");
+    } else if (directory.is_favorite === isFavorite) {
+      throw new IntegrityError(
+        isFavorite ? "Directory already favorited" : "Directory not favorited",
+      );
+    }
+
+    await trx
+      .updateTable("directory")
+      .set({ is_favorite: isFavorite })
+      .where("id", "=", directoryId)
+      .where("user_id", "=", userId)
+      .execute();
+    await trx
+      .insertInto("directory_log")
+      .values({
+        directory_id: directoryId,
+        timestamp: new Date(),
+        action: isFavorite ? "add-to-favorites" : "remove-from-favorites",
+      })
+      .execute();
+  });
+};
+
+export const unregisterDirectory = async (userId: number, directoryId: number) => {
+  return await db
+    .transaction()
+    .setIsolationLevel("repeatable read") // TODO: Sufficient?
+    .execute(async (trx) => {
+      const unregisterFiles = async (parentId: number) => {
+        const files = await trx
+          .selectFrom("file")
+          .leftJoin("thumbnail", "file.id", "thumbnail.file_id")
+          .select(["file.id", "file.path", "thumbnail.path as thumbnailPath"])
+          .where("file.parent_id", "=", parentId)
+          .where("file.user_id", "=", userId)
+          .forUpdate("file")
+          .execute();
+        await trx
+          .deleteFrom("file")
+          .where("parent_id", "=", parentId)
+          .where("user_id", "=", userId)
+          .execute();
+        return files;
+      };
+      const unregisterDirectoryRecursively = async (
+        directoryId: number,
+      ): Promise<{ id: number; path: string; thumbnailPath: string | null }[]> => {
+        const files = await unregisterFiles(directoryId);
+        const subDirectories = await trx
+          .selectFrom("directory")
+          .select("id")
+          .where("parent_id", "=", directoryId)
+          .where("user_id", "=", userId)
+          .execute();
+        const subDirectoryFilePaths = await Promise.all(
+          subDirectories.map(async ({ id }) => await unregisterDirectoryRecursively(id)),
+        );
+
+        const deleteRes = await trx
+          .deleteFrom("directory")
+          .where("id", "=", directoryId)
+          .where("user_id", "=", userId)
+          .executeTakeFirst();
+        if (deleteRes.numDeletedRows === 0n) {
+          throw new IntegrityError("Directory not found");
+        }
+        return files.concat(...subDirectoryFilePaths);
+      };
+      return await unregisterDirectoryRecursively(directoryId);
+    });
+};

src/lib/server/db/file.ts

@@ -1,20 +1,9 @@
-import { sql } from "kysely";
+import { sql, type Selectable } from "kysely";
 import { jsonArrayFrom } from "kysely/helpers/postgres";
 import pg from "pg";
 import { IntegrityError } from "./error";
 import db from "./kysely";
-import type { Ciphertext } from "./schema";
-
-interface Directory {
-  id: number;
-  parentId: DirectoryId;
-  userId: number;
-  mekVersion: number;
-  encDek: string;
-  dekVersion: Date;
-  encName: Ciphertext;
-  isFavorite: boolean;
-}
+import type { Ciphertext, FileTable } from "./schema";
 
 interface File {
   id: number;
@@ -44,209 +33,24 @@ interface FileCategory {
   encName: Ciphertext;
 }
 
-export const registerDirectory = async (params: Omit<Directory, "id" | "isFavorite">) => {
-  await db.transaction().execute(async (trx) => {
-    const mek = await trx
-      .selectFrom("master_encryption_key")
-      .select("version")
-      .where("user_id", "=", params.userId)
-      .where("state", "=", "active")
-      .limit(1)
-      .forUpdate()
-      .executeTakeFirst();
-    if (mek?.version !== params.mekVersion) {
-      throw new IntegrityError("Inactive MEK version");
-    }
-
-    const { directoryId } = await trx
-      .insertInto("directory")
-      .values({
-        parent_id: params.parentId !== "root" ? params.parentId : null,
-        user_id: params.userId,
-        master_encryption_key_version: params.mekVersion,
-        encrypted_data_encryption_key: params.encDek,
-        data_encryption_key_version: params.dekVersion,
-        encrypted_name: params.encName,
-      })
-      .returning("id as directoryId")
-      .executeTakeFirstOrThrow();
-    await trx
-      .insertInto("directory_log")
-      .values({
-        directory_id: directoryId,
-        timestamp: new Date(),
-        action: "create",
-        new_name: params.encName,
-      })
-      .execute();
-  });
-};
-
-export const getAllDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
-  let query = db.selectFrom("directory").selectAll().where("user_id", "=", userId);
-  query =
-    parentId === "root"
-      ? query.where("parent_id", "is", null)
-      : query.where("parent_id", "=", parentId);
-  const directories = await query.execute();
-  return directories.map(
-    (directory) =>
-      ({
-        id: directory.id,
-        parentId: directory.parent_id ?? "root",
-        userId: directory.user_id,
-        mekVersion: directory.master_encryption_key_version,
-        encDek: directory.encrypted_data_encryption_key,
-        dekVersion: directory.data_encryption_key_version,
-        encName: directory.encrypted_name,
-        isFavorite: directory.is_favorite,
-      }) satisfies Directory,
-  );
-};
-
-export const getAllRecursiveDirectoriesByParent = async (userId: number, parentId: DirectoryId) => {
-  const directories = await db
-    .withRecursive("directory_tree", (db) =>
-      db
-        .selectFrom("directory")
-        .selectAll()
-        .$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
-        .$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
-        .where("user_id", "=", userId)
-        .unionAll((db) =>
-          db
-            .selectFrom("directory")
-            .innerJoin("directory_tree", "directory.parent_id", "directory_tree.id")
-            .selectAll("directory"),
-        ),
-    )
-    .selectFrom("directory_tree")
-    .selectAll()
-    .execute();
-  return directories.map(
-    (directory) =>
-      ({
-        id: directory.id,
-        parentId: directory.parent_id ?? "root",
-        userId: directory.user_id,
-        mekVersion: directory.master_encryption_key_version,
-        encDek: directory.encrypted_data_encryption_key,
-        dekVersion: directory.data_encryption_key_version,
-        encName: directory.encrypted_name,
-        isFavorite: directory.is_favorite,
-      }) satisfies Directory,
-  );
-};
-
-export const getDirectory = async (userId: number, directoryId: number) => {
-  const directory = await db
-    .selectFrom("directory")
-    .selectAll()
-    .where("id", "=", directoryId)
-    .where("user_id", "=", userId)
-    .limit(1)
-    .executeTakeFirst();
-  return directory
-    ? ({
-        id: directory.id,
-        parentId: directory.parent_id ?? "root",
-        userId: directory.user_id,
-        mekVersion: directory.master_encryption_key_version,
-        encDek: directory.encrypted_data_encryption_key,
-        dekVersion: directory.data_encryption_key_version,
-        encName: directory.encrypted_name,
-        isFavorite: directory.is_favorite,
-      } satisfies Directory)
-    : null;
-};
-
-export const setDirectoryEncName = async (
-  userId: number,
-  directoryId: number,
-  dekVersion: Date,
-  encName: Ciphertext,
-) => {
-  await db.transaction().execute(async (trx) => {
-    const directory = await trx
-      .selectFrom("directory")
-      .select("data_encryption_key_version")
-      .where("id", "=", directoryId)
-      .where("user_id", "=", userId)
-      .limit(1)
-      .forUpdate()
-      .executeTakeFirst();
-    if (!directory) {
-      throw new IntegrityError("Directory not found");
-    } else if (directory.data_encryption_key_version.getTime() !== dekVersion.getTime()) {
-      throw new IntegrityError("Invalid DEK version");
-    }
-
-    await trx
-      .updateTable("directory")
-      .set({ encrypted_name: encName })
-      .where("id", "=", directoryId)
-      .where("user_id", "=", userId)
-      .execute();
-    await trx
-      .insertInto("directory_log")
-      .values({
-        directory_id: directoryId,
-        timestamp: new Date(),
-        action: "rename",
-        new_name: encName,
-      })
-      .execute();
-  });
-};
-
-export const unregisterDirectory = async (userId: number, directoryId: number) => {
-  return await db
-    .transaction()
-    .setIsolationLevel("repeatable read") // TODO: Sufficient?
-    .execute(async (trx) => {
-      const unregisterFiles = async (parentId: number) => {
-        const files = await trx
-          .selectFrom("file")
-          .leftJoin("thumbnail", "file.id", "thumbnail.file_id")
-          .select(["file.id", "file.path", "thumbnail.path as thumbnailPath"])
-          .where("file.parent_id", "=", parentId)
-          .where("file.user_id", "=", userId)
-          .forUpdate("file")
-          .execute();
-        await trx
-          .deleteFrom("file")
-          .where("parent_id", "=", parentId)
-          .where("user_id", "=", userId)
-          .execute();
-        return files;
-      };
-      const unregisterDirectoryRecursively = async (
-        directoryId: number,
-      ): Promise<{ id: number; path: string; thumbnailPath: string | null }[]> => {
-        const files = await unregisterFiles(directoryId);
-        const subDirectories = await trx
-          .selectFrom("directory")
-          .select("id")
-          .where("parent_id", "=", directoryId)
-          .where("user_id", "=", userId)
-          .execute();
-        const subDirectoryFilePaths = await Promise.all(
-          subDirectories.map(async ({ id }) => await unregisterDirectoryRecursively(id)),
-        );
-
-        const deleteRes = await trx
-          .deleteFrom("directory")
-          .where("id", "=", directoryId)
-          .where("user_id", "=", userId)
-          .executeTakeFirst();
-        if (deleteRes.numDeletedRows === 0n) {
-          throw new IntegrityError("Directory not found");
-        }
-        return files.concat(...subDirectoryFilePaths);
-      };
-      return await unregisterDirectoryRecursively(directoryId);
-    });
-};
+const toFile = (row: Selectable<FileTable>): File => ({
+  id: row.id,
+  parentId: row.parent_id ?? "root",
+  userId: row.user_id,
+  path: row.path,
+  mekVersion: row.master_encryption_key_version,
+  encDek: row.encrypted_data_encryption_key,
+  dekVersion: row.data_encryption_key_version,
+  hskVersion: row.hmac_secret_key_version,
+  contentHmac: row.content_hmac,
+  contentType: row.content_type,
+  encContentIv: row.encrypted_content_iv,
+  encContentHash: row.encrypted_content_hash,
+  encName: row.encrypted_name,
+  encCreatedAt: row.encrypted_created_at,
+  encLastModifiedAt: row.encrypted_last_modified_at,
+  isFavorite: row.is_favorite,
+});
 
 export const registerFile = async (trx: typeof db, params: Omit<File, "id" | "isFavorite">) => {
   if ((params.hskVersion && !params.contentHmac) || (!params.hskVersion && params.contentHmac)) {
@@ -286,33 +90,14 @@ export const registerFile = async (trx: typeof db, params: Omit<File, "id" | "is
 };
 
 export const getAllFilesByParent = async (userId: number, parentId: DirectoryId) => {
-  let query = db.selectFrom("file").selectAll().where("user_id", "=", userId);
-  query =
-    parentId === "root"
-      ? query.where("parent_id", "is", null)
-      : query.where("parent_id", "=", parentId);
-  const files = await query.execute();
-  return files.map(
-    (file) =>
-      ({
-        id: file.id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-      }) satisfies File,
-  );
+  const files = await db
+    .selectFrom("file")
+    .selectAll()
+    .where("user_id", "=", userId)
+    .$if(parentId === "root", (qb) => qb.where("parent_id", "is", null))
+    .$if(parentId !== "root", (qb) => qb.where("parent_id", "=", parentId as number))
+    .execute();
+  return files.map(toFile);
 };
 
 export const getAllFilesByCategory = async (
@@ -345,28 +130,10 @@ export const getAllFilesByCategory = async (
     .orderBy("file_id")
     .orderBy("depth")
     .execute();
-  return files.map(
-    (file) =>
-      ({
-        id: file.file_id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-        isRecursive: file.depth > 0,
-      }) satisfies File & { isRecursive: boolean },
-  );
+  return files.map((file) => ({
+    ...toFile(file),
+    isRecursive: file.depth > 0,
+  }));
 };
 
 export const getAllFileIds = async (userId: number) => {
@@ -382,27 +149,7 @@ export const getLegacyFiles = async (userId: number, limit: number = 100) => {
     .where("encrypted_content_iv", "is not", null)
     .limit(limit)
     .execute();
-  return files.map(
-    (file) =>
-      ({
-        id: file.id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-      }) satisfies File,
-  );
+  return files.map(toFile);
 };
 
 export const getFilesWithoutThumbnail = async (userId: number, limit: number = 100) => {
@@ -426,27 +173,7 @@ export const getFilesWithoutThumbnail = async (userId: number, limit: number = 1
     )
     .limit(limit)
     .execute();
-  return files.map(
-    (file) =>
-      ({
-        id: file.id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-      }) satisfies File,
-  );
+  return files.map(toFile);
 };
 
 export const getAllFileIdsByContentHmac = async (
@@ -472,26 +199,7 @@ export const getFile = async (userId: number, fileId: number) => {
     .where("user_id", "=", userId)
     .limit(1)
     .executeTakeFirst();
-  return file
-    ? ({
-        id: file.id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-      } satisfies File)
-    : null;
+  return file ? toFile(file) : null;
 };
 
 export const getFilesWithCategories = async (userId: number, fileIds: number[]) => {
@@ -510,35 +218,30 @@ export const getFilesWithCategories = async (userId: number, fileIds: number[])
     .where("id", "=", (eb) => eb.fn.any(eb.val(fileIds)))
     .where("user_id", "=", userId)
     .execute();
-  return files.map(
-    (file) =>
-      ({
-        id: file.id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-        categories: file.categories.map((category) => ({
+  return files.map((file) => ({
+    ...toFile(file),
+    categories: file.categories.map(
+      (category) =>
+        ({
           id: category.id,
           parentId: category.parent_id ?? "root",
           mekVersion: category.master_encryption_key_version,
           encDek: category.encrypted_data_encryption_key,
           dekVersion: new Date(category.data_encryption_key_version),
           encName: category.encrypted_name,
-        })),
-      }) satisfies File & { categories: FileCategory[] },
-  );
+        }) satisfies FileCategory,
+    ),
+  }));
+};
+
+export const getAllFavoriteFiles = async (userId: number) => {
+  const files = await db
+    .selectFrom("file")
+    .selectAll()
+    .where("user_id", "=", userId)
+    .where("is_favorite", "=", true)
+    .execute();
+  return files.map(toFile);
 };
 
 export const searchFiles = async (
@@ -625,24 +328,7 @@ export const searchFiles = async (
           )
           .execute()
       : await baseQuery.execute();
-  return files.map((file) => ({
-    id: file.id,
-    parentId: file.parent_id ?? ("root" as const),
-    userId: file.user_id,
-    path: file.path,
-    mekVersion: file.master_encryption_key_version,
-    encDek: file.encrypted_data_encryption_key,
-    dekVersion: file.data_encryption_key_version,
-    hskVersion: file.hmac_secret_key_version,
-    contentHmac: file.content_hmac,
-    contentType: file.content_type,
-    encContentIv: file.encrypted_content_iv,
-    encContentHash: file.encrypted_content_hash,
-    encName: file.encrypted_name,
-    encCreatedAt: file.encrypted_created_at,
-    encLastModifiedAt: file.encrypted_last_modified_at,
-    isFavorite: file.is_favorite,
-  }));
+  return files.map(toFile);
 };
 
 export const setFileEncName = async (
@@ -848,94 +534,3 @@ export const setFileFavorite = async (userId: number, fileId: number, isFavorite
       .execute();
   });
 };
-
-export const setDirectoryFavorite = async (
-  userId: number,
-  directoryId: number,
-  isFavorite: boolean,
-) => {
-  await db.transaction().execute(async (trx) => {
-    const directory = await trx
-      .selectFrom("directory")
-      .select("is_favorite")
-      .where("id", "=", directoryId)
-      .where("user_id", "=", userId)
-      .limit(1)
-      .forUpdate()
-      .executeTakeFirst();
-    if (!directory) {
-      throw new IntegrityError("Directory not found");
-    } else if (directory.is_favorite === isFavorite) {
-      throw new IntegrityError(
-        isFavorite ? "Directory already favorited" : "Directory not favorited",
-      );
-    }
-
-    await trx
-      .updateTable("directory")
-      .set({ is_favorite: isFavorite })
-      .where("id", "=", directoryId)
-      .where("user_id", "=", userId)
-      .execute();
-    await trx
-      .insertInto("directory_log")
-      .values({
-        directory_id: directoryId,
-        timestamp: new Date(),
-        action: isFavorite ? "add-to-favorites" : "remove-from-favorites",
-      })
-      .execute();
-  });
-};
-
-export const getAllFavoriteFiles = async (userId: number) => {
-  const files = await db
-    .selectFrom("file")
-    .selectAll()
-    .where("user_id", "=", userId)
-    .where("is_favorite", "=", true)
-    .execute();
-  return files.map(
-    (file) =>
-      ({
-        id: file.id,
-        parentId: file.parent_id ?? "root",
-        userId: file.user_id,
-        path: file.path,
-        mekVersion: file.master_encryption_key_version,
-        encDek: file.encrypted_data_encryption_key,
-        dekVersion: file.data_encryption_key_version,
-        hskVersion: file.hmac_secret_key_version,
-        contentHmac: file.content_hmac,
-        contentType: file.content_type,
-        encContentIv: file.encrypted_content_iv,
-        encContentHash: file.encrypted_content_hash,
-        encName: file.encrypted_name,
-        encCreatedAt: file.encrypted_created_at,
-        encLastModifiedAt: file.encrypted_last_modified_at,
-        isFavorite: file.is_favorite,
-      }) satisfies File,
-  );
-};
-
-export const getAllFavoriteDirectories = async (userId: number) => {
-  const directories = await db
-    .selectFrom("directory")
-    .selectAll()
-    .where("user_id", "=", userId)
-    .where("is_favorite", "=", true)
-    .execute();
-  return directories.map(
-    (directory) =>
-      ({
-        id: directory.id,
-        parentId: directory.parent_id ?? "root",
-        userId: directory.user_id,
-        mekVersion: directory.master_encryption_key_version,
-        encDek: directory.encrypted_data_encryption_key,
-        dekVersion: directory.data_encryption_key_version,
-        encName: directory.encrypted_name,
-        isFavorite: directory.is_favorite,
-      }) satisfies Directory,
-  );
-};

src/lib/server/db/index.ts

@@ -1,5 +1,6 @@
 export * as CategoryRepo from "./category";
 export * as ClientRepo from "./client";
+export * as DirectoryRepo from "./directory";
 export * as FileRepo from "./file";
 export * as HskRepo from "./hsk";
 export * as MediaRepo from "./media";

src/lib/server/db/migrations/1737357000-Initial.ts

@@ -135,7 +135,7 @@ export const up = async (db: Kysely<any>) => {
     )
     .execute();
 
-  // file.ts
+  // directory.ts
   await db.schema
     .createTable("directory")
     .addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity())
@@ -162,6 +162,8 @@ export const up = async (db: Kysely<any>) => {
     .addColumn("action", "text", (col) => col.notNull())
     .addColumn("new_name", "json")
     .execute();
+
+  // file.ts
   await db.schema
     .createTable("file")
     .addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity())

src/lib/server/db/migrations/1768643000-AddFavorites.ts

@@ -1,12 +1,14 @@
-import { Kysely, sql } from "kysely";
+import { Kysely } from "kysely";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const up = async (db: Kysely<any>) => {
-  // file.ts
+  // directory.ts
   await db.schema
     .alterTable("directory")
     .addColumn("is_favorite", "boolean", (col) => col.notNull().defaultTo(false))
     .execute();
+
+  // file.ts
   await db.schema
     .alterTable("file")
     .addColumn("is_favorite", "boolean", (col) => col.notNull().defaultTo(false))

src/lib/server/db/schema/category.ts

@@ -1,7 +1,7 @@
 import type { Generated } from "kysely";
 import type { Ciphertext } from "./utils";
 
-interface CategoryTable {
+export interface CategoryTable {
   id: Generated<number>;
   parent_id: number | null;
   user_id: number;
@@ -11,7 +11,7 @@ interface CategoryTable {
   encrypted_name: Ciphertext;
 }
 
-interface CategoryLogTable {
+export interface CategoryLogTable {
   id: Generated<number>;
   category_id: number;
   timestamp: Date;

src/lib/server/db/schema/client.ts

@@ -1,6 +1,6 @@
 import type { ColumnType, Generated } from "kysely";
 
-interface ClientTable {
+export interface ClientTable {
   id: Generated<number>;
   encryption_public_key: string; // Base64
   signature_public_key: string; // Base64
@@ -8,13 +8,13 @@ interface ClientTable {
 
 export type UserClientState = "challenging" | "pending" | "active";
 
-interface UserClientTable {
+export interface UserClientTable {
   user_id: number;
   client_id: number;
   state: ColumnType<UserClientState, UserClientState | undefined>;
 }
 
-interface UserClientChallengeTable {
+export interface UserClientChallengeTable {
   id: Generated<number>;
   user_id: number;
   client_id: number;

src/lib/server/db/schema/directory.ts

@@ -0,0 +1,28 @@
+import type { ColumnType, Generated } from "kysely";
+import type { Ciphertext } from "./utils";
+
+export interface DirectoryTable {
+  id: Generated<number>;
+  parent_id: number | null;
+  user_id: number;
+  master_encryption_key_version: number;
+  encrypted_data_encryption_key: string; // Base64
+  data_encryption_key_version: Date;
+  encrypted_name: Ciphertext;
+  is_favorite: Generated<boolean>;
+}
+
+export interface DirectoryLogTable {
+  id: Generated<number>;
+  directory_id: number;
+  timestamp: ColumnType<Date, Date, never>;
+  action: "create" | "rename" | "add-to-favorites" | "remove-from-favorites";
+  new_name: Ciphertext | null;
+}
+
+declare module "./index" {
+  interface Database {
+    directory: DirectoryTable;
+    directory_log: DirectoryLogTable;
+  }
+}

src/lib/server/db/schema/file.ts

@@ -1,26 +1,7 @@
 import type { ColumnType, Generated } from "kysely";
 import type { Ciphertext } from "./utils";
 
-interface DirectoryTable {
-  id: Generated<number>;
-  parent_id: number | null;
-  user_id: number;
-  master_encryption_key_version: number;
-  encrypted_data_encryption_key: string; // Base64
-  data_encryption_key_version: Date;
-  encrypted_name: Ciphertext;
-  is_favorite: Generated<boolean>;
-}
-
-interface DirectoryLogTable {
-  id: Generated<number>;
-  directory_id: number;
-  timestamp: ColumnType<Date, Date, never>;
-  action: "create" | "rename" | "add-to-favorites" | "remove-from-favorites";
-  new_name: Ciphertext | null;
-}
-
-interface FileTable {
+export interface FileTable {
   id: Generated<number>;
   parent_id: number | null;
   user_id: number;
@@ -39,7 +20,7 @@ interface FileTable {
   is_favorite: Generated<boolean>;
 }
 
-interface FileLogTable {
+export interface FileLogTable {
   id: Generated<number>;
   file_id: number;
   timestamp: ColumnType<Date, Date, never>;
@@ -55,15 +36,13 @@ interface FileLogTable {
   category_id: number | null;
 }
 
-interface FileCategoryTable {
+export interface FileCategoryTable {
   file_id: number;
   category_id: number;
 }
 
 declare module "./index" {
   interface Database {
-    directory: DirectoryTable;
-    directory_log: DirectoryLogTable;
     file: FileTable;
     file_log: FileLogTable;
     file_category: FileCategoryTable;

src/lib/server/db/schema/hsk.ts

@@ -2,7 +2,7 @@ import type { ColumnType, Generated } from "kysely";
 
 export type HskState = "active";
 
-interface HskTable {
+export interface HskTable {
   user_id: number;
   version: number;
   state: HskState;
@@ -10,7 +10,7 @@ interface HskTable {
   encrypted_key: string; // Base64
 }
 
-interface HskLogTable {
+export interface HskLogTable {
   id: Generated<number>;
   user_id: number;
   hmac_secret_key_version: number;

src/lib/server/db/schema/index.ts

@@ -1,5 +1,6 @@
 export * from "./category";
 export * from "./client";
+export * from "./directory";
 export * from "./file";
 export * from "./hsk";
 export * from "./media";

src/lib/server/db/schema/media.ts

@@ -1,6 +1,6 @@
 import type { Generated } from "kysely";
 
-interface ThumbnailTable {
+export interface ThumbnailTable {
   id: Generated<number>;
   directory_id: number | null;
   file_id: number | null;

src/lib/server/db/schema/mek.ts

@@ -2,13 +2,13 @@ import type { ColumnType, Generated } from "kysely";
 
 export type MekState = "active" | "retired" | "dead";
 
-interface MekTable {
+export interface MekTable {
   user_id: number;
   version: number;
   state: MekState;
 }
 
-interface MekLogTable {
+export interface MekLogTable {
   id: Generated<number>;
   user_id: number;
   master_encryption_key_version: number;
@@ -17,7 +17,7 @@ interface MekLogTable {
   action_by: number | null;
 }
 
-interface ClientMekTable {
+export interface ClientMekTable {
   user_id: number;
   client_id: number;
   version: number;

src/lib/server/db/schema/session.ts

@@ -1,6 +1,6 @@
 import type { ColumnType, Generated } from "kysely";
 
-interface SessionTable {
+export interface SessionTable {
   id: string;
   user_id: number;
   client_id: number | null;
@@ -10,7 +10,7 @@ interface SessionTable {
   last_used_by_agent: string | null;
 }
 
-interface SessionUpgradeChallengeTable {
+export interface SessionUpgradeChallengeTable {
   id: Generated<number>;
   session_id: string;
   client_id: number;

src/lib/server/db/schema/upload.ts

@@ -1,7 +1,7 @@
 import type { Generated } from "kysely";
 import type { Ciphertext } from "./utils";
 
-interface UploadSessionTable {
+export interface UploadSessionTable {
   id: string;
   type: "file" | "thumbnail" | "migration";
   user_id: number;

src/lib/server/db/schema/user.ts

@@ -1,6 +1,6 @@
 import type { Generated } from "kysely";
 
-interface UserTable {
+export interface UserTable {
   id: Generated<number>;
   email: string;
   nickname: string;

src/lib/types/utils.d.ts

@@ -0,0 +1 @@
+type AllUndefined<T> = { [K in keyof T]?: undefined };

src/routes/(fullscreen)/file/[id]/+page.svelte

@@ -77,12 +77,8 @@
   };
 
   const toggleFavorite = async () => {
-    if (!info?.exists) return;
-    const isFavorite = !!info.isFavorite;
-    const success = await requestFavoriteToggle(data.id, isFavorite);
-    if (success) {
-      info.isFavorite = !isFavorite;
-    }
+    await requestFavoriteToggle(data.id, !!info?.isFavorite);
+    void getFileInfo(data.id, $masterKeyStore?.get(1)?.key!); // TODO: FIXME
   };
 
   $effect(() => {
@@ -154,9 +150,9 @@
   <div onclick={(e) => e.stopPropagation()}>
     <button
       onclick={() => (isMenuOpen = !isMenuOpen)}
-      class="w-[2.3rem] flex-shrink-0 rounded-full p-1 active:bg-black active:bg-opacity-[0.04]"
+      class="w-full rounded-full p-1 text-2xl active:bg-black active:bg-opacity-[0.04]"
     >
-      <IconMoreVert class="text-2xl" />
+      <IconMoreVert />
     </button>
     <TopBarMenu
       bind:isOpen={isMenuOpen}

src/routes/(fullscreen)/file/[id]/TopBarMenu.svelte

@@ -46,7 +46,7 @@
 
 {#if isOpen && (directoryId || downloadUrl || fileBlob)}
   <div
-    class="absolute right-2 top-full z-20 min-w-44 space-y-1 rounded-lg bg-white px-1 py-2 shadow-2xl"
+    class="absolute right-2 top-full z-20 min-w-40 space-y-1 rounded-lg bg-white px-1 py-2 shadow-2xl"
     transition:fly={{ y: -8, duration: 200 }}
   >
     <p class="px-3 pt-2 text-sm font-semibold text-gray-600">더보기</p>
@@ -57,16 +57,14 @@
         onclick: () => void,
       )}
         <button {onclick} class="rounded-xl active:bg-gray-100">
-          <div
-            class="flex items-center gap-x-3 px-3 py-2 text-lg text-gray-700 transition active:scale-95"
-          >
+          <div class="flex items-center gap-x-3 px-3 py-2 text-gray-700 transition active:scale-95">
             <Icon />
             <p class="font-medium">{text}</p>
           </div>
         </button>
       {/snippet}
 
-      {#if typeof isFavorite === "boolean"}
+      {#if isFavorite !== undefined}
         {@render menuButton(
           isFavorite ? IconFavorite : IconFavoriteOutline,
           isFavorite ? "즐겨찾기 해제" : "즐겨찾기",

src/routes/(fullscreen)/file/[id]/service.ts

@@ -58,6 +58,7 @@ export const requestFavoriteToggle = async (fileId: number, isFavorite: boolean)
     }
     return true;
   } catch {
+    // TODO: Error Handling
     return false;
   }
 };

src/routes/(fullscreen)/search/+page.svelte

@@ -25,6 +25,7 @@
     includeImages: boolean;
     includeVideos: boolean;
     includeDirectories: boolean;
+    searchInFavorites: boolean;
     searchInDirectory: boolean;
     categories: SearchFilter["categories"];
   }
@@ -36,6 +37,7 @@
     includeImages: false,
     includeVideos: false,
     includeDirectories: false,
+    searchInFavorites: false,
     searchInDirectory: false,
     categories: [],
   });
@@ -45,6 +47,7 @@
       filters.includeImages ||
       filters.includeVideos ||
       filters.includeDirectories ||
+      filters.searchInFavorites ||
       filters.name.trim().length > 0,
   );
 
@@ -81,7 +84,9 @@
 
     return sortEntries(
       [...directories, ...files].filter(
-        ({ name }) => !nameFilter || searchString(name, nameFilter),
+        (entry) =>
+          (!nameFilter || searchString(entry.name, nameFilter)) &&
+          (!filters.searchInFavorites || entry.isFavorite),
       ),
     );
   });
@@ -118,7 +123,7 @@
     },
   };
 
-  $effect(() => {
+  $effect.pre(() => {
     if (data.directoryId) {
       HybridPromise.resolve(getDirectoryInfo(data.directoryId, $masterKeyStore?.get(1)?.key!)).then(
         (res) => {
@@ -132,6 +137,10 @@
     }
   });
 
+  $effect.pre(() => {
+    filters.searchInFavorites = data.fromFavorites;
+  });
+
   $effect(() => {
     // Svelte sucks
     hasAnyFilter;
@@ -172,6 +181,7 @@
           {#if !hasCategoryFilter}
             <Chip bind:selected={filters.includeDirectories}>폴더</Chip>
           {/if}
+          <Chip bind:selected={filters.searchInFavorites}>즐겨찾기</Chip>
           {#if directoryInfo?.exists}
             <Chip bind:selected={filters.searchInDirectory}>
               위치: {directoryInfo.name}

src/routes/(fullscreen)/search/+page.ts

@@ -4,15 +4,18 @@ import type { PageLoad } from "./$types";
 
 export const load: PageLoad = ({ url }) => {
   const directoryId = url.searchParams.get("directoryId");
+  const from = url.searchParams.get("from");
 
   const zodRes = z
     .object({
       directoryId: z.coerce.number().int().positive().nullable(),
+      from: z.enum(["favorites"]).nullable(),
     })
-    .safeParse({ directoryId });
+    .safeParse({ directoryId, from });
   if (!zodRes.success) error(400, "Invalid query parameters");
 
   return {
     directoryId: zodRes.data.directoryId,
+    fromFavorites: zodRes.data.from === "favorites",
   };
 };

src/routes/(fullscreen)/search/service.ts

@@ -1,6 +1,4 @@
 import {
-  decryptDirectoryMetadata,
-  decryptFileMetadata,
   getDirectoryInfo,
   getFileInfo,
   type LocalDirectoryInfo,
@@ -30,49 +28,14 @@ export const requestSearch = async (filter: SearchFilter, masterKey: CryptoKey)
       .filter(({ type }) => type === "exclude")
       .map(({ info }) => info.id),
   });
-
   const [directories, files] = await HybridPromise.all([
     HybridPromise.all(
       directoriesRaw.map((directory) =>
-        HybridPromise.resolve(
-          getDirectoryInfo(directory.id, masterKey, {
-            async fetchFromServer(id, cachedInfo, masterKey) {
-              const metadata = await decryptDirectoryMetadata(directory, masterKey);
-              return {
-                subDirectories: [],
-                files: [],
-                ...cachedInfo,
-                id: id as number,
-                exists: true,
-                parentId: directory.parent,
-                ...metadata,
-                isFavorite: !!directory.isFavorite,
-              };
-            },
-          }),
-        ),
+        getDirectoryInfo(directory.id, masterKey, { serverResponse: directory }),
       ),
     ),
     HybridPromise.all(
-      filesRaw.map((file) =>
-        HybridPromise.resolve(
-          getFileInfo(file.id, masterKey, {
-            async fetchFromServer(id, cachedInfo, masterKey) {
-              const metadata = await decryptFileMetadata(file, masterKey);
-              return {
-                categories: [],
-                ...cachedInfo,
-                id: id as number,
-                exists: true,
-                parentId: file.parent,
-                contentType: file.contentType,
-                isFavorite: !!file.isFavorite,
-                ...metadata,
-              };
-            },
-          }),
-        ),
-      ),
+      filesRaw.map((file) => getFileInfo(file.id, masterKey, { serverResponse: file })),
     ),
   ]);
   return { directories, files } as SearchResult;

src/routes/(fullscreen)/settings/migration/service.svelte.ts

@@ -1,12 +1,7 @@
 import { limitFunction } from "p-limit";
 import { SvelteMap } from "svelte/reactivity";
 import { CHUNK_SIZE } from "$lib/constants";
-import {
-  decryptFileMetadata,
-  getFileInfo,
-  type FileInfo,
-  type MaybeFileInfo,
-} from "$lib/modules/filesystem";
+import { getFileInfo, type FileInfo } from "$lib/modules/filesystem";
 import { uploadBlob } from "$lib/modules/upload";
 import { requestFileDownload } from "$lib/services/file";
 import { HybridPromise, Scheduler } from "$lib/utils";
@@ -35,28 +30,9 @@ export const requestLegacyFiles = async (
   masterKey: CryptoKey,
 ) => {
   const files = await HybridPromise.all(
-    filesRaw.map((file) =>
-      HybridPromise.resolve(
-        getFileInfo(file.id, masterKey, {
-          async fetchFromServer(id, cachedInfo, masterKey) {
-            const metadata = await decryptFileMetadata(file, masterKey);
-            return {
-              categories: [],
-              ...cachedInfo,
-              id: id as number,
-              exists: true,
-              isLegacy: file.isLegacy,
-              parentId: file.parent,
-              contentType: file.contentType,
-              ...metadata,
-            };
-          },
-        }),
-      ),
-    ),
+    filesRaw.map((file) => getFileInfo(file.id, masterKey, { serverResponse: file })),
   );
-
-  return files as MaybeFileInfo[];
+  return files;
 };
 
 const createState = (status: MigrationStatus): MigrationState => {

src/routes/(fullscreen)/settings/thumbnail/service.ts

@@ -1,12 +1,7 @@
 import { limitFunction } from "p-limit";
 import { SvelteMap } from "svelte/reactivity";
 import { storeFileThumbnailCache } from "$lib/modules/file";
-import {
-  decryptFileMetadata,
-  getFileInfo,
-  type FileInfo,
-  type MaybeFileInfo,
-} from "$lib/modules/filesystem";
+import { getFileInfo, type FileInfo } from "$lib/modules/filesystem";
 import { generateThumbnail } from "$lib/modules/thumbnail";
 import { requestFileDownload, requestFileThumbnailUpload } from "$lib/services/file";
 import { HybridPromise, Scheduler } from "$lib/utils";
@@ -40,28 +35,9 @@ export const requestMissingThumbnailFiles = async (
   masterKey: CryptoKey,
 ) => {
   const files = await HybridPromise.all(
-    filesRaw.map((file) =>
-      HybridPromise.resolve(
-        getFileInfo(file.id, masterKey, {
-          async fetchFromServer(id, cachedInfo, masterKey) {
-            const metadata = await decryptFileMetadata(file, masterKey);
-            return {
-              categories: [],
-              ...cachedInfo,
-              id: id as number,
-              exists: true,
-              isLegacy: file.isLegacy,
-              parentId: file.parent,
-              contentType: file.contentType,
-              ...metadata,
-            };
-          },
-        }),
-      ),
-    ),
+    filesRaw.map((file) => getFileInfo(file.id, masterKey, { serverResponse: file })),
   );
-
-  return files as MaybeFileInfo[];
+  return files;
 };
 
 const requestThumbnailUpload = limitFunction(

src/routes/(main)/directory/[[id]]/DirectoryEntries/File.svelte

@@ -24,7 +24,7 @@
       id: info.id,
       dataKey: info.dataKey,
       name: info.name,
-      isFavorite: info.isFavorite ?? false,
+      isFavorite: info.isFavorite,
     });
   };
 </script>

src/routes/(main)/directory/[[id]]/DirectoryEntries/SubDirectory.svelte

@@ -20,7 +20,7 @@
       id: info.id,
       dataKey: info.dataKey,
       name: info.name,
-      isFavorite: info.isFavorite ?? false,
+      isFavorite: info.isFavorite,
     });
   };
 </script>

src/routes/(main)/favorites/+page.svelte

@@ -2,11 +2,14 @@
   import { onMount } from "svelte";
   import { goto } from "$app/navigation";
   import { RowVirtualizer } from "$lib/components/atoms";
+  import { TopBar } from "$lib/components/molecules";
   import { masterKeyStore } from "$lib/stores";
   import Directory from "./Directory.svelte";
   import File from "./File.svelte";
   import { requestFavoriteEntries, requestRemoveFavorite, type FavoriteEntry } from "./service";
 
+  import IconSearch from "~icons/material-symbols/search";
+
   let { data } = $props();
 
   let entries: FavoriteEntry[] = $state([]);
@@ -41,14 +44,22 @@
   <title>즐겨찾기</title>
 </svelte:head>
 
-<div class="flex h-full flex-col p-4">
+<TopBar title="즐겨찾기" showBackButton={false}>
+  <button
+    onclick={() => goto("/search?from=favorites")}
+    class="w-full rounded-full p-1 text-2xl active:bg-black active:bg-opacity-[0.04]"
+  >
+    <IconSearch />
+  </button>
+</TopBar>
+<div class="flex h-full flex-col p-4 !pt-0">
   {#if isLoading}
     <div class="flex flex-grow items-center justify-center">
       <p class="text-gray-500">
         {#if data.favorites.files.length === 0 && data.favorites.directories.length === 0}
           즐겨찾기한 항목이 없어요.
         {:else}
-          로딩 중...
+          즐겨찾기 목록을 불러오고 있어요.
         {/if}
       </p>
     </div>

src/routes/(main)/favorites/Directory.svelte

@@ -20,5 +20,5 @@
   actionButtonIcon={IconClose}
   onActionButtonClick={onRemoveClick}
 >
-  <DirectoryEntryLabel type="directory" name={info.name} />
+  <DirectoryEntryLabel type="directory" name={info.name} isFavorite />
 </ActionEntryButton>

src/routes/(main)/favorites/File.svelte

@@ -23,5 +23,5 @@
   actionButtonIcon={IconClose}
   onActionButtonClick={onRemoveClick}
 >
-  <DirectoryEntryLabel type="file" thumbnail={$thumbnail} name={info.name} />
+  <DirectoryEntryLabel type="file" thumbnail={$thumbnail} name={info.name} isFavorite />
 </ActionEntryButton>

src/routes/(main)/favorites/service.ts

@@ -1,9 +1,9 @@
 import {
-  decryptDirectoryMetadata,
-  decryptFileMetadata,
+  getDirectoryInfo,
   getFileInfo,
   type SummarizedFileInfo,
   type SubDirectoryInfo,
+  type LocalDirectoryInfo,
 } from "$lib/modules/filesystem";
 import { HybridPromise, sortEntries } from "$lib/utils";
 import { trpc } from "$trpc/client";
@@ -16,59 +16,41 @@ export type FavoriteEntry =
 export const requestFavoriteEntries = async (
   favorites: RouterOutputs["favorites"]["get"],
   masterKey: CryptoKey,
-): Promise<FavoriteEntry[]> => {
-  const directories: FavoriteEntry[] = await Promise.all(
-    favorites.directories.map(async (dir) => {
-      const metadata = await decryptDirectoryMetadata(dir, masterKey);
-      return {
-        type: "directory" as const,
-        name: metadata.name,
-        details: {
-          id: dir.id,
-          parentId: dir.parent,
-          isFavorite: true,
-          dataKey: metadata.dataKey,
-          name: metadata.name,
-        } as SubDirectoryInfo,
-      };
-    }),
-  );
-
-  const fileResults = await Promise.all(
-    favorites.files.map(async (file) => {
-      const result = await HybridPromise.resolve(
-        getFileInfo(file.id, masterKey, {
-          async fetchFromServer(id, cachedInfo) {
-            const metadata = await decryptFileMetadata(file, masterKey);
-            return {
-              categories: [],
-              ...cachedInfo,
-              id: id as number,
-              exists: true,
-              parentId: file.parent,
-              contentType: file.contentType,
-              isFavorite: true,
-              ...metadata,
-            };
-          },
+) => {
+  const [directories, files] = await HybridPromise.all([
+    HybridPromise.all(
+      favorites.directories.map((directory) =>
+        getDirectoryInfo(directory.id, masterKey, {
+          serverResponse: { ...directory, isFavorite: true },
         }),
-      );
-      if (result?.exists) {
-        return {
-          type: "file" as const,
-          name: result.name,
-          details: result as SummarizedFileInfo,
-        };
-      }
-      return null;
-    }),
-  );
-
-  const files = fileResults.filter(
-    (f): f is { type: "file"; name: string; details: SummarizedFileInfo } => f !== null,
-  );
-
-  return [...sortEntries(directories), ...sortEntries(files)];
+      ),
+    ),
+    HybridPromise.all(
+      favorites.files.map((file) =>
+        getFileInfo(file.id, masterKey, { serverResponse: { ...file, isFavorite: true } }),
+      ),
+    ),
+  ]);
+  return [
+    ...sortEntries(
+      directories.map(
+        (directory): FavoriteEntry => ({
+          type: "directory",
+          name: directory.name!,
+          details: directory as LocalDirectoryInfo,
+        }),
+      ),
+    ),
+    ...sortEntries(
+      files.map(
+        (file): FavoriteEntry => ({
+          type: "file",
+          name: file.name!,
+          details: file as SummarizedFileInfo,
+        }),
+      ),
+    ),
+  ];
 };
 
 export const requestRemoveFavorite = async (type: "file" | "directory", id: number) => {

src/trpc/routers/directory.ts

@@ -1,7 +1,7 @@
 import { TRPCError } from "@trpc/server";
 import { z } from "zod";
 import { DirectoryIdSchema } from "$lib/schemas";
-import { FileRepo, IntegrityError } from "$lib/server/db";
+import { DirectoryRepo, FileRepo, IntegrityError } from "$lib/server/db";
 import { safeUnlink } from "$lib/server/modules/filesystem";
 import { router, roleProcedure } from "../init.server";
 
@@ -14,13 +14,15 @@ const directoryRouter = router({
     )
     .query(async ({ ctx, input }) => {
       const directory =
-        input.id !== "root" ? await FileRepo.getDirectory(ctx.session.userId, input.id) : undefined;
+        input.id !== "root"
+          ? await DirectoryRepo.getDirectory(ctx.session.userId, input.id)
+          : undefined;
       if (directory === null) {
         throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
       }
 
       const [directories, files] = await Promise.all([
-        FileRepo.getAllDirectoriesByParent(ctx.session.userId, input.id),
+        DirectoryRepo.getAllDirectoriesByParent(ctx.session.userId, input.id),
         FileRepo.getAllFilesByParent(ctx.session.userId, input.id),
       ]);
       return {
@@ -78,7 +80,7 @@ const directoryRouter = router({
       }
 
       try {
-        await FileRepo.registerDirectory({
+        await DirectoryRepo.registerDirectory({
           parentId: input.parent,
           userId: ctx.session.userId,
           mekVersion: input.mekVersion,
@@ -105,7 +107,7 @@ const directoryRouter = router({
     )
     .mutation(async ({ ctx, input }) => {
       try {
-        await FileRepo.setDirectoryEncName(ctx.session.userId, input.id, input.dekVersion, {
+        await DirectoryRepo.setDirectoryEncName(ctx.session.userId, input.id, input.dekVersion, {
           ciphertext: input.name,
           iv: input.nameIv,
         });
@@ -129,7 +131,7 @@ const directoryRouter = router({
     )
     .mutation(async ({ ctx, input }) => {
       try {
-        const files = await FileRepo.unregisterDirectory(ctx.session.userId, input.id);
+        const files = await DirectoryRepo.unregisterDirectory(ctx.session.userId, input.id);
         return {
           deletedFiles: files.map((file) => {
             safeUnlink(file.path); // Intended

src/trpc/routers/favorites.ts

@@ -1,15 +1,24 @@
 import { TRPCError } from "@trpc/server";
 import { z } from "zod";
-import { FileRepo, IntegrityError } from "$lib/server/db";
+import { DirectoryRepo, FileRepo, IntegrityError } from "$lib/server/db";
 import { router, roleProcedure } from "../init.server";
 
 const favoritesRouter = router({
   get: roleProcedure["activeClient"].query(async ({ ctx }) => {
-    const [files, directories] = await Promise.all([
+    const [directories, files] = await Promise.all([
+      DirectoryRepo.getAllFavoriteDirectories(ctx.session.userId),
       FileRepo.getAllFavoriteFiles(ctx.session.userId),
-      FileRepo.getAllFavoriteDirectories(ctx.session.userId),
     ]);
     return {
+      directories: directories.map((directory) => ({
+        id: directory.id,
+        parent: directory.parentId,
+        mekVersion: directory.mekVersion,
+        dek: directory.encDek,
+        dekVersion: directory.dekVersion,
+        name: directory.encName.ciphertext,
+        nameIv: directory.encName.iv,
+      })),
       files: files.map((file) => ({
         id: file.id,
         parent: file.parentId,
@@ -24,18 +33,51 @@ const favoritesRouter = router({
         lastModifiedAt: file.encLastModifiedAt.ciphertext,
         lastModifiedAtIv: file.encLastModifiedAt.iv,
       })),
-      directories: directories.map((directory) => ({
-        id: directory.id,
-        parent: directory.parentId,
-        mekVersion: directory.mekVersion,
-        dek: directory.encDek,
-        dekVersion: directory.dekVersion,
-        name: directory.encName.ciphertext,
-        nameIv: directory.encName.iv,
-      })),
     };
   }),
 
+  addDirectory: roleProcedure["activeClient"]
+    .input(
+      z.object({
+        id: z.int().positive(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      try {
+        await DirectoryRepo.setDirectoryFavorite(ctx.session.userId, input.id, true);
+      } catch (e) {
+        if (e instanceof IntegrityError) {
+          if (e.message === "Directory not found") {
+            throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
+          } else if (e.message === "Directory already favorited") {
+            throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
+          }
+        }
+        throw e;
+      }
+    }),
+
+  removeDirectory: roleProcedure["activeClient"]
+    .input(
+      z.object({
+        id: z.int().positive(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      try {
+        await DirectoryRepo.setDirectoryFavorite(ctx.session.userId, input.id, false);
+      } catch (e) {
+        if (e instanceof IntegrityError) {
+          if (e.message === "Directory not found") {
+            throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
+          } else if (e.message === "Directory not favorited") {
+            throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
+          }
+        }
+        throw e;
+      }
+    }),
+
   addFile: roleProcedure["activeClient"]
     .input(
       z.object({
@@ -77,48 +119,6 @@ const favoritesRouter = router({
         throw e;
       }
     }),
-
-  addDirectory: roleProcedure["activeClient"]
-    .input(
-      z.object({
-        id: z.int().positive(),
-      }),
-    )
-    .mutation(async ({ ctx, input }) => {
-      try {
-        await FileRepo.setDirectoryFavorite(ctx.session.userId, input.id, true);
-      } catch (e) {
-        if (e instanceof IntegrityError) {
-          if (e.message === "Directory not found") {
-            throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
-          } else if (e.message === "Directory already favorited") {
-            throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
-          }
-        }
-        throw e;
-      }
-    }),
-
-  removeDirectory: roleProcedure["activeClient"]
-    .input(
-      z.object({
-        id: z.int().positive(),
-      }),
-    )
-    .mutation(async ({ ctx, input }) => {
-      try {
-        await FileRepo.setDirectoryFavorite(ctx.session.userId, input.id, false);
-      } catch (e) {
-        if (e instanceof IntegrityError) {
-          if (e.message === "Directory not found") {
-            throw new TRPCError({ code: "NOT_FOUND", message: "Invalid directory id" });
-          } else if (e.message === "Directory not favorited") {
-            throw new TRPCError({ code: "BAD_REQUEST", message: e.message });
-          }
-        }
-        throw e;
-      }
-    }),
 });
 
 export default favoritesRouter;

src/trpc/routers/file.ts

@@ -114,6 +114,7 @@ const fileRouter = router({
       createdAtIv: file.encCreatedAt?.iv,
       lastModifiedAt: file.encLastModifiedAt.ciphertext,
       lastModifiedAtIv: file.encLastModifiedAt.iv,
+      isFavorite: file.isFavorite,
     }));
   }),
 
@@ -133,6 +134,7 @@ const fileRouter = router({
       createdAtIv: file.encCreatedAt?.iv,
       lastModifiedAt: file.encLastModifiedAt.ciphertext,
       lastModifiedAtIv: file.encLastModifiedAt.iv,
+      isFavorite: file.isFavorite,
     }));
   }),
 

src/trpc/routers/search.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { DirectoryIdSchema } from "$lib/schemas";
-import { FileRepo } from "$lib/server/db";
+import { DirectoryRepo, FileRepo } from "$lib/server/db";
 import { router, roleProcedure } from "../init.server";
 
 const searchRouter = router({
@@ -15,7 +15,7 @@ const searchRouter = router({
     .query(async ({ ctx, input }) => {
       const [directories, files] = await Promise.all([
         input.includeCategories.length === 0 && input.excludeCategories.length === 0
-          ? FileRepo.getAllRecursiveDirectoriesByParent(ctx.session.userId, input.ancestor)
+          ? DirectoryRepo.getAllRecursiveDirectoriesByParent(ctx.session.userId, input.ancestor)
           : [],
         FileRepo.searchFiles(ctx.session.userId, {
           parentId: input.ancestor,