파일 및 디렉터리 목록을 IndexedDB에 캐싱하도록 구현

2025-12-16 15:08:46 +00:00 · 2025-01-17 12:22:51 +09:00
parent 7e711c1b8f
commit 7aa6ba0eab
23 changed files with 285 additions and 165 deletions
--- a/src/lib/indexedDB/filesystem.ts
+++ b/src/lib/indexedDB/filesystem.ts
@@ -0,0 +1,52 @@
+import { Dexie, type EntityTable } from "dexie";
+
+export type DirectoryId = "root" | number;
+
+interface DirectoryInfo {
+  id: number;
+  parentId: DirectoryId;
+  name: string;
+}
+
+interface FileInfo {
+  id: number;
+  parentId: DirectoryId;
+  name: string;
+  contentType: string;
+  createdAt?: Date;
+  lastModifiedAt: Date;
+}
+
+const filesystem = new Dexie("filesystem") as Dexie & {
+  directory: EntityTable<DirectoryInfo, "id">;
+  file: EntityTable<FileInfo, "id">;
+};
+
+filesystem.version(1).stores({
+  directory: "id, parentId",
+  file: "id, parentId",
+});
+
+export const getDirectoryInfos = async (parentId: DirectoryId) => {
+  return await filesystem.directory.where({ parentId }).toArray();
+};
+
+export const getDirectoryInfo = async (id: number) => {
+  return await filesystem.directory.get(id);
+};
+
+export const storeDirectoryInfo = async (directoryInfo: DirectoryInfo) => {
+  await filesystem.directory.put(directoryInfo);
+};
+
+export const getFileInfos = async (parentId: DirectoryId) => {
+  return await filesystem.file.where({ parentId }).toArray();
+};
+
+export const getFileInfo = async (id: number) => {
+  return await filesystem.file.get(id);
+};
+
+export const storeFileInfo = async (fileInfo: FileInfo) => {
+  await filesystem.file.put(fileInfo);
+};
--- a/src/lib/indexedDB/index.ts
+++ b/src/lib/indexedDB/index.ts
@@ -1,2 +1,3 @@
 export * from "./cacheIndex";
+export * from "./filesystem";
 export * from "./keyStore";
--- a/src/lib/modules/file/index.ts
+++ b/src/lib/modules/file/index.ts
@@ -1,3 +1,2 @@
 export * from "./cache";
-export * from "./info";
 export * from "./upload";
--- a/src/lib/modules/file/info.ts
+++ b/src/lib/modules/file/info.ts
@@ -1,104 +0,0 @@
-import { writable, type Writable } from "svelte/store";
-import { callGetApi } from "$lib/hooks";
-import { unwrapDataKey, decryptString } from "$lib/modules/crypto";
-import type { DirectoryInfoResponse, FileInfoResponse } from "$lib/server/schemas";
-import {
-  directoryInfoStore,
-  fileInfoStore,
-  type DirectoryInfo,
-  type FileInfo,
-} from "$lib/stores/file";
-
-const fetchDirectoryInfo = async (
-  directoryId: "root" | number,
-  masterKey: CryptoKey,
-  infoStore: Writable<DirectoryInfo | null>,
-) => {
-  const res = await callGetApi(`/api/directory/${directoryId}`);
-  if (!res.ok) throw new Error("Failed to fetch directory information");
-  const { metadata, subDirectories, files }: DirectoryInfoResponse = await res.json();
-
-  let newInfo: DirectoryInfo;
-  if (directoryId === "root") {
-    newInfo = {
-      id: "root",
-      subDirectoryIds: subDirectories,
-      fileIds: files,
-    };
-  } else {
-    const { dataKey } = await unwrapDataKey(metadata!.dek, masterKey);
-    newInfo = {
-      id: directoryId,
-      dataKey,
-      dataKeyVersion: new Date(metadata!.dekVersion),
-      name: await decryptString(metadata!.name, metadata!.nameIv, dataKey),
-      subDirectoryIds: subDirectories,
-      fileIds: files,
-    };
-  }
-
-  infoStore.update(() => newInfo);
-};
-
-export const getDirectoryInfo = (directoryId: "root" | number, masterKey: CryptoKey) => {
-  // TODO: MEK rotation
-
-  let info = directoryInfoStore.get(directoryId);
-  if (!info) {
-    info = writable(null);
-    directoryInfoStore.set(directoryId, info);
-  }
-
-  fetchDirectoryInfo(directoryId, masterKey, info);
-  return info;
-};
-
-const decryptDate = async (ciphertext: string, iv: string, dataKey: CryptoKey) => {
-  return new Date(parseInt(await decryptString(ciphertext, iv, dataKey), 10));
-};
-
-const fetchFileInfo = async (
-  fileId: number,
-  masterKey: CryptoKey,
-  infoStore: Writable<FileInfo | null>,
-) => {
-  const res = await callGetApi(`/api/file/${fileId}`);
-  if (!res.ok) {
-    if (res.status === 404) {
-      infoStore.update(() => null);
-      return;
-    }
-    throw new Error("Failed to fetch file information");
-  }
-  const metadata: FileInfoResponse = await res.json();
-
-  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
-  const newInfo: FileInfo = {
-    id: fileId,
-    dataKey,
-    dataKeyVersion: new Date(metadata.dekVersion),
-    contentType: metadata.contentType,
-    contentIv: metadata.contentIv,
-    name: await decryptString(metadata.name, metadata.nameIv, dataKey),
-    createdAt:
-      metadata.createdAt && metadata.createdAtIv
-        ? await decryptDate(metadata.createdAt, metadata.createdAtIv, dataKey)
-        : undefined,
-    lastModifiedAt: await decryptDate(metadata.lastModifiedAt, metadata.lastModifiedAtIv, dataKey),
-  };
-
-  infoStore.update(() => newInfo);
-};
-
-export const getFileInfo = (fileId: number, masterKey: CryptoKey) => {
-  // TODO: MEK rotation
-
-  let info = fileInfoStore.get(fileId);
-  if (!info) {
-    info = writable(null);
-    fileInfoStore.set(fileId, info);
-  }
-
-  fetchFileInfo(fileId, masterKey, info);
-  return info;
-};
--- a/src/lib/modules/file/upload.ts
+++ b/src/lib/modules/file/upload.ts
@@ -191,7 +191,7 @@ export const uploadFile = async (
    form.set(
      "metadata",
      JSON.stringify({
-        parentId,
+        parent: parentId,
        mekVersion: masterKey.version,
        dek: dataKeyWrapped,
        dekVersion: dataKeyVersion.toISOString(),
--- a/src/lib/modules/filesystem.ts
+++ b/src/lib/modules/filesystem.ts
@@ -0,0 +1,192 @@
+import { get, writable, type Writable } from "svelte/store";
+import { callGetApi } from "$lib/hooks";
+import {
+  getDirectoryInfos as getDirectoryInfosFromIndexedDB,
+  getDirectoryInfo as getDirectoryInfoFromIndexedDB,
+  storeDirectoryInfo,
+  getFileInfos as getFileInfosFromIndexedDB,
+  getFileInfo as getFileInfoFromIndexedDB,
+  storeFileInfo,
+  type DirectoryId,
+} from "$lib/indexedDB";
+import { unwrapDataKey, decryptString } from "$lib/modules/crypto";
+import type { DirectoryInfoResponse, FileInfoResponse } from "$lib/server/schemas";
+
+export type DirectoryInfo =
+  | {
+      id: "root";
+      dataKey?: undefined;
+      dataKeyVersion?: undefined;
+      name?: undefined;
+      subDirectoryIds: number[];
+      fileIds: number[];
+    }
+  | {
+      id: number;
+      dataKey?: CryptoKey;
+      dataKeyVersion?: Date;
+      name: string;
+      subDirectoryIds: number[];
+      fileIds: number[];
+    };
+
+export interface FileInfo {
+  id: number;
+  dataKey?: CryptoKey;
+  dataKeyVersion?: Date;
+  contentType: string;
+  contentIv?: string;
+  name: string;
+  createdAt?: Date;
+  lastModifiedAt: Date;
+}
+
+const directoryInfoStore = new Map<DirectoryId, Writable<DirectoryInfo | null>>();
+const fileInfoStore = new Map<number, Writable<FileInfo | null>>();
+
+const fetchDirectoryInfoFromIndexedDB = async (
+  id: DirectoryId,
+  info: Writable<DirectoryInfo | null>,
+) => {
+  if (get(info)) return;
+
+  const [directory, subDirectories, files] = await Promise.all([
+    id !== "root" ? getDirectoryInfoFromIndexedDB(id) : undefined,
+    getDirectoryInfosFromIndexedDB(id),
+    getFileInfosFromIndexedDB(id),
+  ]);
+  const subDirectoryIds = subDirectories.map(({ id }) => id);
+  const fileIds = files.map(({ id }) => id);
+
+  if (id === "root") {
+    info.set({ id, subDirectoryIds, fileIds });
+  } else {
+    if (!directory) return;
+    info.set({ id, name: directory.name, subDirectoryIds, fileIds });
+  }
+};
+
+const fetchDirectoryInfoFromServer = async (
+  id: DirectoryId,
+  info: Writable<DirectoryInfo | null>,
+  masterKey: CryptoKey,
+) => {
+  const res = await callGetApi(`/api/directory/${id}`);
+  if (!res.ok) throw new Error("Failed to fetch directory information"); // TODO: Handle 404
+  const {
+    metadata,
+    subDirectories: subDirectoryIds,
+    files: fileIds,
+  }: DirectoryInfoResponse = await res.json();
+
+  if (id === "root") {
+    info.set({ id, subDirectoryIds, fileIds });
+  } else {
+    const { dataKey } = await unwrapDataKey(metadata!.dek, masterKey);
+    const name = await decryptString(metadata!.name, metadata!.nameIv, dataKey);
+
+    info.set({
+      id,
+      dataKey,
+      dataKeyVersion: new Date(metadata!.dekVersion),
+      name,
+      subDirectoryIds,
+      fileIds,
+    });
+    await storeDirectoryInfo({ id, parentId: metadata!.parent, name });
+  }
+};
+
+const fetchDirectoryInfo = async (
+  id: DirectoryId,
+  info: Writable<DirectoryInfo | null>,
+  masterKey: CryptoKey,
+) => {
+  await fetchDirectoryInfoFromIndexedDB(id, info);
+  await fetchDirectoryInfoFromServer(id, info, masterKey);
+};
+
+export const getDirectoryInfo = (id: DirectoryId, masterKey: CryptoKey) => {
+  // TODO: MEK rotation
+
+  let info = directoryInfoStore.get(id);
+  if (!info) {
+    info = writable(null);
+    directoryInfoStore.set(id, info);
+  }
+
+  fetchDirectoryInfo(id, info, masterKey);
+  return info;
+};
+
+const fetchFileInfoFromIndexedDB = async (id: number, info: Writable<FileInfo | null>) => {
+  if (get(info)) return;
+
+  const file = await getFileInfoFromIndexedDB(id);
+  if (!file) return;
+
+  info.set(file);
+};
+
+const decryptDate = async (ciphertext: string, iv: string, dataKey: CryptoKey) => {
+  return new Date(parseInt(await decryptString(ciphertext, iv, dataKey), 10));
+};
+
+const fetchFileInfoFromServer = async (
+  id: number,
+  info: Writable<FileInfo | null>,
+  masterKey: CryptoKey,
+) => {
+  const res = await callGetApi(`/api/file/${id}`);
+  if (!res.ok) throw new Error("Failed to fetch file information"); // TODO: Handle 404
+  const metadata: FileInfoResponse = await res.json();
+
+  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
+  const name = await decryptString(metadata.name, metadata.nameIv, dataKey);
+  const createdAt =
+    metadata.createdAt && metadata.createdAtIv
+      ? await decryptDate(metadata.createdAt, metadata.createdAtIv, dataKey)
+      : undefined;
+  const lastModifiedAt = await decryptDate(
+    metadata.lastModifiedAt,
+    metadata.lastModifiedAtIv,
+    dataKey,
+  );
+
+  info.set({
+    id,
+    dataKey,
+    dataKeyVersion: new Date(metadata.dekVersion),
+    contentType: metadata.contentType,
+    contentIv: metadata.contentIv,
+    name,
+    createdAt,
+    lastModifiedAt,
+  });
+  await storeFileInfo({
+    id,
+    parentId: metadata.parent,
+    name,
+    contentType: metadata.contentType,
+    createdAt,
+    lastModifiedAt,
+  });
+};
+
+const fetchFileInfo = async (id: number, info: Writable<FileInfo | null>, masterKey: CryptoKey) => {
+  await fetchFileInfoFromIndexedDB(id, info);
+  await fetchFileInfoFromServer(id, info, masterKey);
+};
+
+export const getFileInfo = (fileId: number, masterKey: CryptoKey) => {
+  // TODO: MEK rotation
+
+  let info = fileInfoStore.get(fileId);
+  if (!info) {
+    info = writable(null);
+    fileInfoStore.set(fileId, info);
+  }
+
+  fetchFileInfo(fileId, info, masterKey);
+  return info;
+};
--- a/src/lib/server/schemas/directory.ts
+++ b/src/lib/server/schemas/directory.ts
@@ -3,6 +3,7 @@ import { z } from "zod";
 export const directoryInfoResponse = z.object({
  metadata: z
    .object({
+      parent: z.union([z.enum(["root"]), z.number().int().positive()]),
      mekVersion: z.number().int().positive(),
      dek: z.string().base64().nonempty(),
      dekVersion: z.string().datetime(),
@@ -28,7 +29,7 @@ export const directoryRenameRequest = z.object({
 export type DirectoryRenameRequest = z.infer<typeof directoryRenameRequest>;

 export const directoryCreateRequest = z.object({
-  parentId: z.union([z.enum(["root"]), z.number().int().positive()]),
+  parent: z.union([z.enum(["root"]), z.number().int().positive()]),
  mekVersion: z.number().int().positive(),
  dek: z.string().base64().nonempty(),
  dekVersion: z.string().datetime(),
--- a/src/lib/server/schemas/file.ts
+++ b/src/lib/server/schemas/file.ts
@@ -2,6 +2,7 @@ import mime from "mime";
 import { z } from "zod";

 export const fileInfoResponse = z.object({
+  parent: z.union([z.enum(["root"]), z.number().int().positive()]),
  mekVersion: z.number().int().positive(),
  dek: z.string().base64().nonempty(),
  dekVersion: z.string().datetime(),
@@ -38,7 +39,7 @@ export const duplicateFileScanResponse = z.object({
 export type DuplicateFileScanResponse = z.infer<typeof duplicateFileScanResponse>;

 export const fileUploadRequest = z.object({
-  parentId: z.union([z.enum(["root"]), z.number().int().positive()]),
+  parent: z.union([z.enum(["root"]), z.number().int().positive()]),
  mekVersion: z.number().int().positive(),
  dek: z.string().base64().nonempty(),
  dekVersion: z.string().datetime(),
--- a/src/lib/server/services/directory.ts
+++ b/src/lib/server/services/directory.ts
@@ -19,9 +19,9 @@ export const getDirectoryInformation = async (userId: number, directoryId: "root

  const directories = await getAllDirectoriesByParent(userId, directoryId);
  const files = await getAllFilesByParent(userId, directoryId);
-
  return {
    metadata: directory && {
+      parentId: directory.parentId ?? ("root" as const),
      mekVersion: directory.mekVersion,
      encDek: directory.encDek,
      dekVersion: directory.dekVersion,
--- a/src/lib/server/services/file.ts
+++ b/src/lib/server/services/file.ts
@@ -23,6 +23,7 @@ export const getFileInformation = async (userId: number, fileId: number) => {
  }

  return {
+    parentId: file.parentId ?? ("root" as const),
    mekVersion: file.mekVersion,
    encDek: file.encDek,
    dekVersion: file.dekVersion,
--- a/src/lib/stores/file.ts
+++ b/src/lib/stores/file.ts
@@ -1,34 +1,4 @@
 import { writable, type Writable } from "svelte/store";
-
-export type DirectoryInfo =
-  | {
-      id: "root";
-      dataKey?: undefined;
-      dataKeyVersion?: undefined;
-      name?: undefined;
-      subDirectoryIds: number[];
-      fileIds: number[];
-    }
-  | {
-      id: number;
-      dataKey: CryptoKey;
-      dataKeyVersion: Date;
-      name: string;
-      subDirectoryIds: number[];
-      fileIds: number[];
-    };
-
-export interface FileInfo {
-  id: number;
-  dataKey: CryptoKey;
-  dataKeyVersion: Date;
-  contentType: string;
-  contentIv: string;
-  name: string;
-  createdAt?: Date;
-  lastModifiedAt: Date;
-}
-
 export interface FileUploadStatus {
  name: string;
  parentId: "root" | number;
@@ -45,8 +15,4 @@ export interface FileUploadStatus {
  estimated?: number;
 }

-export const directoryInfoStore = new Map<"root" | number, Writable<DirectoryInfo | null>>();
-
-export const fileInfoStore = new Map<number, Writable<FileInfo | null>>();
-
 export const fileUploadStatusStore = writable<Writable<FileUploadStatus>[]>([]);