add missing load implementation

Author: yujonglee

apps/desktop/src/store/tinybase/persister/chat/load.ts

@@ -0,0 +1,79 @@
+import { sep } from "@tauri-apps/api/path";
+import { readDir, readTextFile } from "@tauri-apps/plugin-fs";
+
+import type { ChatGroup, ChatMessageStorage } from "@hypr/store";
+
+import { isFileNotFoundError, isUUID } from "../utils";
+
+type ChatGroupData = {
+  id: string;
+  user_id: string;
+  created_at: string;
+  title: string;
+};
+
+type ChatMessageWithId = ChatMessageStorage & { id: string };
+
+type ChatJson = {
+  chat_group: ChatGroupData;
+  messages: ChatMessageWithId[];
+};
+
+export type LoadedChatData = {
+  chat_groups: Record<string, ChatGroup>;
+  chat_messages: Record<string, ChatMessageStorage>;
+};
+
+const LABEL = "ChatPersister";
+
+export async function loadAllChatData(
+  dataDir: string,
+): Promise<LoadedChatData> {
+  const result: LoadedChatData = {
+    chat_groups: {},
+    chat_messages: {},
+  };
+
+  const chatsDir = [dataDir, "chats"].join(sep());
+
+  let entries: { name: string; isDirectory: boolean }[];
+  try {
+    entries = await readDir(chatsDir);
+  } catch (error) {
+    if (!isFileNotFoundError(error)) {
+      console.error(`[${LABEL}] load error:`, error);
+    }
+    return result;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory) continue;
+    if (!isUUID(entry.name)) continue;
+
+    const chatGroupId = entry.name;
+    const messagesPath = [chatsDir, chatGroupId, "_messages.json"].join(sep());
+
+    try {
+      const content = await readTextFile(messagesPath);
+      const data = JSON.parse(content) as ChatJson;
+
+      const { id: _groupId, ...chatGroupData } = data.chat_group;
+      result.chat_groups[chatGroupId] = chatGroupData;
+
+      for (const message of data.messages) {
+        const { id: messageId, ...messageData } = message;
+        result.chat_messages[messageId] = messageData;
+      }
+    } catch (error) {
+      if (!isFileNotFoundError(error)) {
+        console.error(
+          `[${LABEL}] Failed to load chat from ${messagesPath}:`,
+          error,
+        );
+      }
+      continue;
+    }
+  }
+
+  return result;
+}

apps/desktop/src/store/tinybase/persister/chat/persister.ts

@@ -1,13 +1,40 @@
-import type { MergeableStore, OptionalSchemas } from "tinybase/with-schemas";
+import type {
+  Content,
+  MergeableStore,
+  OptionalSchemas,
+} from "tinybase/with-schemas";
 
-import { createSessionDirPersister } from "../utils";
+import { createSessionDirPersister, getDataDir } from "../utils";
 import { collectChatWriteOps } from "./collect";
+import { loadAllChatData } from "./load";
 
 export function createChatPersister<Schemas extends OptionalSchemas>(
   store: MergeableStore<Schemas>,
 ) {
   return createSessionDirPersister(store, {
     label: "ChatPersister",
     collect: (_store, tables, dataDir) => collectChatWriteOps(tables, dataDir),
+    load: async (): Promise<Content<Schemas> | undefined> => {
+      try {
+        const dataDir = await getDataDir();
+        const data = await loadAllChatData(dataDir);
+        const hasData =
+          Object.keys(data.chat_groups).length > 0 ||
+          Object.keys(data.chat_messages).length > 0;
+        if (!hasData) {
+          return undefined;
+        }
+        return [
+          {
+            chat_groups: data.chat_groups,
+            chat_messages: data.chat_messages,
+          },
+          {},
+        ] as unknown as Content<Schemas>;
+      } catch (error) {
+        console.error("[ChatPersister] load error:", error);
+        return undefined;
+      }
+    },
   });
 }

apps/desktop/src/store/tinybase/persister/note/collect.ts

@@ -1,19 +1,28 @@
 import { sep } from "@tauri-apps/api/path";
 import type { MergeableStore, OptionalSchemas } from "tinybase/with-schemas";
 
+import type { ParsedDocument } from "@hypr/plugin-frontmatter";
 import type { EnhancedNoteStorage } from "@hypr/store";
-import { isValidTiptapContent } from "@hypr/tiptap/shared";
+import { isValidTiptapContent, json2md } from "@hypr/tiptap/shared";
 
 import {
   type CollectorResult,
   getSessionDir,
   iterateTableRows,
-  type JsonValue,
   sanitizeFilename,
   type TablesContent,
 } from "../utils";
 
-function parseTiptapContent(content: string): JsonValue | undefined {
+export type NoteFrontmatter = {
+  id: string;
+  session_id: string;
+  type: "enhanced_note" | "memo";
+  template_id?: string;
+  position?: number;
+  title?: string;
+};
+
+function tryParseAndConvertToMarkdown(content: string): string | undefined {
   let parsed: unknown;
   try {
     parsed = JSON.parse(content);
@@ -25,7 +34,7 @@ function parseTiptapContent(content: string): JsonValue | undefined {
     return undefined;
   }
 
-  return parsed as JsonValue;
+  return json2md(parsed);
 }
 
 function getEnhancedNoteFilename<Schemas extends OptionalSchemas>(
@@ -53,20 +62,29 @@ export function collectNoteWriteOps<Schemas extends OptionalSchemas>(
   dataDir: string,
 ): CollectorResult {
   const dirs = new Set<string>();
-  const mdBatchItems: Array<[JsonValue, string]> = [];
+  const frontmatterBatchItems: Array<[ParsedDocument, string]> = [];
 
   for (const enhancedNote of iterateTableRows(tables, "enhanced_notes")) {
     if (!enhancedNote.content || !enhancedNote.session_id) {
       continue;
     }
 
-    const parsed = parseTiptapContent(enhancedNote.content);
-    if (!parsed) {
+    const markdown = tryParseAndConvertToMarkdown(enhancedNote.content);
+    if (!markdown) {
       continue;
     }
 
     const filename = getEnhancedNoteFilename(store, enhancedNote);
 
+    const frontmatter: NoteFrontmatter = {
+      id: enhancedNote.id,
+      session_id: enhancedNote.session_id,
+      type: "enhanced_note",
+      template_id: enhancedNote.template_id || undefined,
+      position: enhancedNote.position,
+      title: enhancedNote.title || undefined,
+    };
+
     const session = tables.sessions?.[enhancedNote.session_id];
     const folderPath = session?.folder_id ?? "";
     const sessionDir = getSessionDir(
@@ -75,28 +93,43 @@ export function collectNoteWriteOps<Schemas extends OptionalSchemas>(
       folderPath,
     );
     dirs.add(sessionDir);
-    mdBatchItems.push([parsed, [sessionDir, filename].join(sep())]);
+    frontmatterBatchItems.push([
+      { frontmatter, content: markdown },
+      [sessionDir, filename].join(sep()),
+    ]);
   }
 
   for (const session of iterateTableRows(tables, "sessions")) {
     if (!session.raw_md) {
       continue;
     }
 
-    const parsed = parseTiptapContent(session.raw_md);
-    if (!parsed) {
+    const markdown = tryParseAndConvertToMarkdown(session.raw_md);
+    if (!markdown) {
       continue;
     }
 
+    const frontmatter: NoteFrontmatter = {
+      id: session.id,
+      session_id: session.id,
+      type: "memo",
+    };
+
     const folderPath = session.folder_id ?? "";
     const sessionDir = getSessionDir(dataDir, session.id, folderPath);
     dirs.add(sessionDir);
-    mdBatchItems.push([parsed, [sessionDir, "_memo.md"].join(sep())]);
+    frontmatterBatchItems.push([
+      { frontmatter, content: markdown },
+      [sessionDir, "_memo.md"].join(sep()),
+    ]);
   }
 
   const operations: CollectorResult["operations"] = [];
-  if (mdBatchItems.length > 0) {
-    operations.push({ type: "md-batch", items: mdBatchItems });
+  if (frontmatterBatchItems.length > 0) {
+    operations.push({
+      type: "frontmatter-batch",
+      items: frontmatterBatchItems,
+    });
   }
 
   return { dirs, operations };

apps/desktop/src/store/tinybase/persister/note/load.ts

@@ -0,0 +1,134 @@
+import { sep } from "@tauri-apps/api/path";
+import { exists, readDir, readTextFile } from "@tauri-apps/plugin-fs";
+
+import { commands as frontmatterCommands } from "@hypr/plugin-frontmatter";
+import type { EnhancedNoteStorage } from "@hypr/store";
+import { md2json } from "@hypr/tiptap/shared";
+
+import { isFileNotFoundError } from "../utils";
+import type { NoteFrontmatter } from "./collect";
+
+export type LoadedNoteData = {
+  enhanced_notes: Record<string, EnhancedNoteStorage>;
+  session_raw_md: Record<string, string>;
+};
+
+const LABEL = "NotePersister";
+
+async function loadNotesRecursively(
+  sessionsDir: string,
+  currentPath: string,
+  result: LoadedNoteData,
+): Promise<void> {
+  const s = sep();
+  const fullPath = currentPath
+    ? [sessionsDir, currentPath].join(s)
+    : sessionsDir;
+
+  let entries: { name: string; isDirectory: boolean }[];
+  try {
+    entries = await readDir(fullPath);
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.isDirectory) {
+      const entryPath = currentPath
+        ? [currentPath, entry.name].join(s)
+        : entry.name;
+      const metaPath = [sessionsDir, entryPath, "_meta.json"].join(s);
+      const hasMetaJson = await exists(metaPath);
+
+      if (hasMetaJson) {
+        await loadNotesFromSessionDir(sessionsDir, entryPath, result);
+      } else {
+        await loadNotesRecursively(sessionsDir, entryPath, result);
+      }
+    }
+  }
+}
+
+async function loadNotesFromSessionDir(
+  sessionsDir: string,
+  sessionPath: string,
+  result: LoadedNoteData,
+): Promise<void> {
+  const s = sep();
+  const sessionDir = [sessionsDir, sessionPath].join(s);
+
+  let entries: { name: string; isDirectory: boolean }[];
+  try {
+    entries = await readDir(sessionDir);
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.isDirectory) continue;
+    if (!entry.name.endsWith(".md")) continue;
+
+    const filePath = [sessionDir, entry.name].join(s);
+
+    try {
+      const content = await readTextFile(filePath);
+      const parseResult = await frontmatterCommands.deserialize(content);
+
+      if (parseResult.status === "error") {
+        console.error(
+          `[${LABEL}] Failed to parse frontmatter from ${filePath}:`,
+          parseResult.error,
+        );
+        continue;
+      }
+
+      const { frontmatter, content: markdownBody } = parseResult.data;
+      const fm = frontmatter as NoteFrontmatter;
+
+      if (!fm.id || !fm.session_id || !fm.type) {
+        continue;
+      }
+
+      const tiptapJson = md2json(markdownBody);
+      const tiptapContent = JSON.stringify(tiptapJson);
+
+      if (fm.type === "memo") {
+        result.session_raw_md[fm.session_id] = tiptapContent;
+      } else if (fm.type === "enhanced_note") {
+        result.enhanced_notes[fm.id] = {
+          user_id: "",
+          created_at: new Date().toISOString(),
+          session_id: fm.session_id,
+          content: tiptapContent,
+          template_id: fm.template_id ?? "",
+          position: fm.position ?? 0,
+          title: fm.title ?? "",
+        };
+      }
+    } catch (error) {
+      console.error(`[${LABEL}] Failed to load note from ${filePath}:`, error);
+      continue;
+    }
+  }
+}
+
+export async function loadAllNoteData(
+  dataDir: string,
+): Promise<LoadedNoteData> {
+  const result: LoadedNoteData = {
+    enhanced_notes: {},
+    session_raw_md: {},
+  };
+
+  const sessionsDir = [dataDir, "sessions"].join(sep());
+
+  try {
+    await loadNotesRecursively(sessionsDir, "", result);
+  } catch (error) {
+    if (!isFileNotFoundError(error)) {
+      console.error(`[${LABEL}] load error:`, error);
+    }
+  }
+
+  return result;
+}