파일 및 디렉터리 메타데이터 복호화 로직 리팩토링

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>({

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>({
@@ -106,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>({
@@ -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;