프론트엔드 파일시스템 모듈 리팩토링

src/lib/modules/filesystem/category.ts

@@ -0,0 +1,104 @@
+import * as IndexedDB from "$lib/indexedDB";
+import { trpc, isTRPCClientError } from "$trpc/client";
+import { FilesystemCache, decryptFileMetadata, decryptCategoryMetadata } from "./internal.svelte";
+import type { CategoryInfo } from "./types";
+
+const cache = new FilesystemCache<CategoryId, CategoryInfo, Partial<CategoryInfo>>();
+
+const fetchFromIndexedDB = async (id: CategoryId) => {
+  const [category, subCategories] = await Promise.all([
+    id !== "root" ? IndexedDB.getCategoryInfo(id) : undefined,
+    IndexedDB.getCategoryInfos(id),
+  ]);
+  const files = category
+    ? await Promise.all(
+        category.files.map(async (file) => {
+          const fileInfo = await IndexedDB.getFileInfo(file.id);
+          return fileInfo
+            ? {
+                id: file.id,
+                contentType: fileInfo.contentType,
+                name: fileInfo.name,
+                createdAt: fileInfo.createdAt,
+                lastModifiedAt: fileInfo.lastModifiedAt,
+                isRecursive: file.isRecursive,
+              }
+            : undefined;
+        }),
+      )
+    : undefined;
+
+  if (id === "root") {
+    return { id, subCategories };
+  } else if (category) {
+    return {
+      id,
+      name: category.name,
+      subCategories,
+      files: files!.filter((file) => !!file),
+      isFileRecursive: category.isFileRecursive,
+    };
+  }
+};
+
+const fetchFromServer = async (id: CategoryId, masterKey: CryptoKey) => {
+  try {
+    const {
+      metadata,
+      subCategories: subCategoriesRaw,
+      files: filesRaw,
+    } = await trpc().category.get.query({ id });
+    const [subCategories, files] = await Promise.all([
+      Promise.all(
+        subCategoriesRaw.map(async (category) => ({
+          id: category.id,
+          ...(await decryptCategoryMetadata(category, masterKey)),
+        })),
+      ),
+      filesRaw
+        ? Promise.all(
+            filesRaw.map(async (file) => ({
+              id: file.id,
+              contentType: file.contentType,
+              isRecursive: file.isRecursive,
+              ...(await decryptFileMetadata(file, masterKey)),
+            })),
+          )
+        : undefined,
+    ]);
+
+    if (id === "root") {
+      return { id, subCategories };
+    } else {
+      return {
+        id,
+        subCategories,
+        files,
+        ...(await decryptCategoryMetadata(metadata!, masterKey)),
+      };
+    }
+  } catch (e) {
+    if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
+      cache.delete(id);
+      await IndexedDB.deleteCategoryInfo(id as number);
+      return;
+    }
+    throw e;
+  }
+};
+
+export const getCategoryInfo = async (id: CategoryId, masterKey: CryptoKey) => {
+  return await cache.get(id, async (isInitial, resolve) => {
+    if (isInitial) {
+      const info = await fetchFromIndexedDB(id);
+      if (info) {
+        resolve(info);
+      }
+    }
+
+    const info = await fetchFromServer(id, masterKey);
+    if (info) {
+      resolve(info);
+    }
+  });
+};

src/lib/modules/filesystem/directory.ts

@@ -0,0 +1,74 @@
+import * as IndexedDB from "$lib/indexedDB";
+import { monotonicResolve } from "$lib/utils";
+import { trpc, isTRPCClientError } from "$trpc/client";
+import { FilesystemCache, decryptDirectoryMetadata, decryptFileMetadata } from "./internal.svelte";
+import type { DirectoryInfo } from "./types";
+
+const cache = new FilesystemCache<DirectoryId, DirectoryInfo>();
+
+const fetchFromIndexedDB = async (id: DirectoryId) => {
+  const [directory, subDirectories, files] = await Promise.all([
+    id !== "root" ? IndexedDB.getDirectoryInfo(id) : undefined,
+    IndexedDB.getDirectoryInfos(id),
+    IndexedDB.getFileInfos(id),
+  ]);
+
+  if (id === "root") {
+    return { id, subDirectories, files };
+  } else if (directory) {
+    return { id, parentId: directory.parentId, name: directory.name, subDirectories, files };
+  }
+};
+
+const fetchFromServer = async (id: DirectoryId, masterKey: CryptoKey) => {
+  try {
+    const {
+      metadata,
+      subDirectories: subDirectoriesRaw,
+      files: filesRaw,
+    } = await trpc().directory.get.query({ id });
+    const [subDirectories, files] = await Promise.all([
+      Promise.all(
+        subDirectoriesRaw.map(async (directory) => ({
+          id: directory.id,
+          ...(await decryptDirectoryMetadata(directory, masterKey)),
+        })),
+      ),
+      Promise.all(
+        filesRaw.map(async (file) => ({
+          id: file.id,
+          contentType: file.contentType,
+          ...(await decryptFileMetadata(file, masterKey)),
+        })),
+      ),
+    ]);
+
+    if (id === "root") {
+      return { id, subDirectories, files };
+    } else {
+      return {
+        id,
+        parentId: metadata!.parent,
+        subDirectories,
+        files,
+        ...(await decryptDirectoryMetadata(metadata!, masterKey)),
+      };
+    }
+  } catch (e) {
+    if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
+      cache.delete(id);
+      await IndexedDB.deleteDirectoryInfo(id as number);
+      return;
+    }
+    throw e;
+  }
+};
+
+export const getDirectoryInfo = async (id: DirectoryId, masterKey: CryptoKey) => {
+  return await cache.get(id, (isInitial, resolve) =>
+    monotonicResolve(
+      [isInitial && fetchFromIndexedDB(id), fetchFromServer(id, masterKey)],
+      resolve,
+    ),
+  );
+};

src/lib/modules/filesystem/file.ts

@@ -0,0 +1,70 @@
+import * as IndexedDB from "$lib/indexedDB";
+import { monotonicResolve } from "$lib/utils";
+import { trpc, isTRPCClientError } from "$trpc/client";
+import { FilesystemCache, decryptFileMetadata, decryptCategoryMetadata } from "./internal.svelte";
+import type { FileInfo } from "./types";
+
+const cache = new FilesystemCache<number, FileInfo>();
+
+const fetchFromIndexedDB = async (id: number) => {
+  const file = await IndexedDB.getFileInfo(id);
+  const categories = file
+    ? await Promise.all(
+        file.categoryIds.map(async (categoryId) => {
+          const category = await IndexedDB.getCategoryInfo(categoryId);
+          return category ? { id: category.id, name: category.name } : undefined;
+        }),
+      )
+    : undefined;
+
+  if (file) {
+    return {
+      id,
+      parentId: file.parentId,
+      contentType: file.contentType,
+      name: file.name,
+      createdAt: file.createdAt,
+      lastModifiedAt: file.lastModifiedAt,
+      categories: categories!.filter((category) => !!category),
+    };
+  }
+};
+
+const fetchFromServer = async (id: number, masterKey: CryptoKey) => {
+  try {
+    const { categories: categoriesRaw, ...metadata } = await trpc().file.get.query({ id });
+    const [categories] = await Promise.all([
+      Promise.all(
+        categoriesRaw.map(async (category) => ({
+          id: category.id,
+          ...(await decryptCategoryMetadata(category, masterKey)),
+        })),
+      ),
+    ]);
+
+    return {
+      id,
+      parentId: metadata.parent,
+      contentType: metadata.contentType,
+      contentIv: metadata.contentIv,
+      categories,
+      ...(await decryptFileMetadata(metadata, masterKey)),
+    };
+  } catch (e) {
+    if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
+      cache.delete(id);
+      await IndexedDB.deleteFileInfo(id);
+      return;
+    }
+    throw e;
+  }
+};
+
+export const getFileInfo = async (id: number, masterKey: CryptoKey) => {
+  return await cache.get(id, (isInitial, resolve) =>
+    monotonicResolve(
+      [isInitial && fetchFromIndexedDB(id), fetchFromServer(id, masterKey)],
+      resolve,
+    ),
+  );
+};

src/lib/modules/filesystem/index.ts

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

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

@@ -0,0 +1,84 @@
+import { unwrapDataKey, decryptString } from "$lib/modules/crypto";
+
+export class FilesystemCache<K, V extends RV, RV = V> {
+  private map = new Map<K, V | Promise<V>>();
+
+  get(key: K, loader: (isInitial: boolean, resolve: (value: RV) => void) => void) {
+    const info = this.map.get(key);
+    if (info instanceof Promise) {
+      return info;
+    }
+
+    const { promise, resolve } = Promise.withResolvers<V>();
+    if (!info) {
+      this.map.set(key, promise);
+    }
+
+    loader(!info, (loadedInfo) => {
+      let info = this.map.get(key)!;
+      if (info instanceof Promise) {
+        const state = $state(loadedInfo);
+        this.map.set(key, state as V);
+        resolve(state as V);
+      } else {
+        Object.assign(info, loadedInfo);
+        resolve(info);
+      }
+    });
+
+    return info ?? promise;
+  }
+
+  delete(key: K) {
+    this.map.delete(key);
+  }
+}
+
+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

@@ -0,0 +1,62 @@
+type DataKey = { key: CryptoKey; version: Date };
+
+interface LocalDirectoryInfo {
+  id: number;
+  parentId: DirectoryId;
+  dataKey?: DataKey;
+  name: string;
+  subDirectories: SubDirectoryInfo[];
+  files: SummarizedFileInfo[];
+}
+
+interface RootDirectoryInfo {
+  id: "root";
+  parentId?: undefined;
+  dataKey?: undefined;
+  dataKeyVersion?: undefined;
+  name?: undefined;
+  subDirectories: SubDirectoryInfo[];
+  files: SummarizedFileInfo[];
+}
+
+export type DirectoryInfo = LocalDirectoryInfo | RootDirectoryInfo;
+export type SubDirectoryInfo = Omit<LocalDirectoryInfo, "parentId" | "subDirectories" | "files">;
+
+export interface FileInfo {
+  id: number;
+  parentId: DirectoryId;
+  dataKey?: DataKey;
+  contentType: string;
+  contentIv?: string;
+  name: string;
+  createdAt?: Date;
+  lastModifiedAt: Date;
+  categories: { id: number; name: string }[];
+}
+
+export type SummarizedFileInfo = Omit<FileInfo, "parentId" | "contentIv" | "categories">;
+export type CategoryFileInfo = SummarizedFileInfo & { isRecursive: boolean };
+
+interface LocalCategoryInfo {
+  id: number;
+  dataKey?: DataKey | undefined;
+  name: string;
+  subCategories: SubCategoryInfo[];
+  files: CategoryFileInfo[];
+  isFileRecursive: boolean;
+}
+
+interface RootCategoryInfo {
+  id: "root";
+  dataKey?: undefined;
+  name?: undefined;
+  subCategories: SubCategoryInfo[];
+  files?: undefined;
+  isFileRecursive?: undefined;
+}
+
+export type CategoryInfo = LocalCategoryInfo | RootCategoryInfo;
+export type SubCategoryInfo = Omit<
+  LocalCategoryInfo,
+  "subCategories" | "files" | "isFileRecursive"
+>;