guesung · guesung · Jan 1, 2025 · Dec 25, 2024 · Dec 25, 2024 · Dec 25, 2024
@@ -36,3 +36,6 @@ vite.config.**
 
 # Turborepo
 .turbo
+
+# windsurf
+.windsurfrules
@@ -111,9 +111,9 @@
       "prettier . --write"
     ]
   },
+  "sideEffects": false,
   "packageManager": "pnpm@9.5.0",
   "engines": {
     "node": ">=18.12.0"
-  },
-  "sideEffects": false
+  }
 }
@@ -5,7 +5,7 @@ export const PATHS = {
   memos: '/memos',
   auth: '/auth',
   introduce: '/introduce',
-  updates: '/updates',
+  update: '/update',
   memosWish: '/memos?isWish=true',
   memosSetting: '/memos/setting',
   callbackOAuth: '/auth/callback',

@@ -1,22 +1,55 @@
+import { getChoseong } from 'es-hangul';
 import { QUERY_KEY } from '@src/constants';
 import { MemoService } from '@src/utils';
 import { useSuspenseQuery } from '@tanstack/react-query';
 
 import useSupabaseClientQuery from './useSupabaseClientQuery';
+import { MemoRow } from '@src/types';
 
-type QueryData = Awaited<ReturnType<MemoService['getMemos']>>;
+type QueryFnData = Awaited<ReturnType<MemoService['getMemos']>>;
 type QueryError = Error;
+type QueryData = MemoRow[];
 
-export default function useMemosQuery() {
+interface UseMemosQueryProps {
+  category?: string;
+  isWish?: string;
+  searchQuery?: string;
+  searchTarget?: string;
+}
+
+export default function useMemosQuery({ category, isWish, searchQuery, searchTarget }: UseMemosQueryProps = {}) {
   const { data: supabaseClient } = useSupabaseClientQuery();
+  const searchQueryLower = searchQuery?.toLowerCase();
+
+  const query = useSuspenseQuery<QueryFnData, QueryError, QueryData>({
+    queryFn: new MemoService(supabaseClient).getMemos,
+    select: ({ data: memos }) => {
+      return (
+        memos
+          ?.filter(memo => !!isWish === !!memo.isWish)
+          .filter(memo => (category ? memo.category?.name === category : true))
+          .filter(memo => {
+            if (!searchQueryLower) return true;
+
+            const isTitleMatch =
+              memo.title?.toLowerCase().includes(searchQueryLower) ||
+              getChoseong(memo.title).includes(searchQueryLower);
+            const isMemoMatch =
+              memo.memo?.toLowerCase().includes(searchQueryLower) || getChoseong(memo.memo).includes(searchQueryLower);
+            const isCategoryMatch = memo.category?.name.toLowerCase().includes(searchQueryLower);
 
-  const query = useSuspenseQuery<QueryData, QueryError>({
-    queryFn: () => new MemoService(supabaseClient).getMemos(),
+            if (isCategoryMatch) return true;
+            if (searchTarget === 'title') return isTitleMatch;
+            if (searchTarget === 'memo') return isMemoMatch;
+            return isTitleMatch || isMemoMatch;
+          }) ?? []
+      );
+    },
     queryKey: QUERY_KEY.memos(),
   });
 
   return {
     ...query,
-    memos: query.data?.data ?? [],
+    memos: query.data ?? [],
   };
 }
@@ -1,50 +1,93 @@
 import { EXTENSION } from '@src/constants';
 import { Runtime, Tab } from '@src/utils/extension';
 import { YoutubeTranscript } from 'youtube-transcript';
-
 import { BRIDGE_MESSAGE_TYPES, Category } from './constant';
+import { ExtensionError, ExtensionErrorCode, PageContent } from './types';
 
 export default class ExtensionBridge {
-  static requestGetSidePanelOpen(callbackFn: () => void) {
-    chrome.runtime.sendMessage(EXTENSION.id, { type: BRIDGE_MESSAGE_TYPES.GET_SIDE_PANEL_OPEN }, callbackFn);
+  static async requestGetSidePanelOpen(callbackFn: () => void) {
+    try {
+      chrome.runtime.sendMessage(
+        EXTENSION.id,
+        {
+          type: BRIDGE_MESSAGE_TYPES.GET_SIDE_PANEL_OPEN,
+        },
+        callbackFn,
+      );
+    } catch (error) {
+      throw new ExtensionError(
+        'Failed to request side panel open status',
+        ExtensionErrorCode.COMMUNICATION_ERROR,
+        error,
+      );
+    }
   }
 
   static responseGetSidePanelOpen() {
-    Runtime.onMessageExternal(BRIDGE_MESSAGE_TYPES.GET_SIDE_PANEL_OPEN, (_, __, sendResponse) => {
-      sendResponse(true);
-    });
-  }
-
-  static requestOpenSidePanel() {
-    return Runtime.sendMessage(BRIDGE_MESSAGE_TYPES.OPEN_SIDE_PANEL);
+    try {
+      Runtime.onMessageExternal(BRIDGE_MESSAGE_TYPES.GET_SIDE_PANEL_OPEN, (_, __, sendResponse) => {
+        sendResponse(true);
+      });
+    } catch (error) {
+      throw new ExtensionError(
+        'Failed to respond to side panel open status request',
+        ExtensionErrorCode.RUNTIME_ERROR,
+        error,
+      );
+    }
+  }
+
+  static async requestOpenSidePanel() {
+    try {
+      return await Runtime.sendMessage(BRIDGE_MESSAGE_TYPES.OPEN_SIDE_PANEL);
+    } catch (error) {
+      throw new ExtensionError('Failed to request side panel open', ExtensionErrorCode.RUNTIME_ERROR, error);
+    }
   }
 
   static responseOpenSidePanel() {
-    chrome.runtime.onMessage.addListener((request, sender) => {
-      if (request.type === BRIDGE_MESSAGE_TYPES.OPEN_SIDE_PANEL) {
-        if (!sender.tab?.windowId) return;
-        chrome.sidePanel.open({ windowId: sender.tab.windowId });
-      }
-    });
-  }
-
-  static requestGetTabs() {
-    return Runtime.sendMessage<null, chrome.tabs.Tab>(BRIDGE_MESSAGE_TYPES.GET_TABS);
+    try {
+      chrome.runtime.onMessage.addListener((request, sender) => {
+        if (request.type === BRIDGE_MESSAGE_TYPES.OPEN_SIDE_PANEL) {
+          if (!sender.tab?.windowId) {
+            throw new ExtensionError('No window ID found', ExtensionErrorCode.TAB_ERROR);
+          }
+          chrome.sidePanel.open({ windowId: sender.tab.windowId });
+        }
+      });
+    } catch (error) {
+      throw new ExtensionError('Failed to respond to open side panel request', ExtensionErrorCode.RUNTIME_ERROR, error);
+    }
+  }
+
+  static async requestGetTabs() {
+    try {
+      return await Runtime.sendMessage<null, chrome.tabs.Tab>(BRIDGE_MESSAGE_TYPES.GET_TABS);
+    } catch (error) {
+      throw new ExtensionError('Failed to request tabs', ExtensionErrorCode.TAB_ERROR, error);
+    }
   }
 
   static async responseGetTabs() {
-    const tabs = await Tab.get();
-
-    Runtime.onMessage(BRIDGE_MESSAGE_TYPES.GET_TABS, (_, __, sendResponse) => {
-      sendResponse(tabs);
-    });
+    try {
+      const tabs = await Tab.get();
+      Runtime.onMessage(BRIDGE_MESSAGE_TYPES.GET_TABS, (_, __, sendResponse) => {
+        sendResponse(tabs);
+      });
+    } catch (error) {
+      throw new ExtensionError('Failed to respond to get tabs request', ExtensionErrorCode.TAB_ERROR, error);
+    }
   }
 
-  static requestPageContent() {
-    return Tab.sendMessage<void, { content: string; category: Category }>(BRIDGE_MESSAGE_TYPES.PAGE_CONTENT);
+  static async requestPageContent(): Promise<PageContent> {
+    try {
+      return await Tab.sendMessage<void, PageContent>(BRIDGE_MESSAGE_TYPES.PAGE_CONTENT);
+    } catch (error) {
+      throw new ExtensionError('Failed to request page content', ExtensionErrorCode.CONTENT_ERROR, error);
+    }
   }
 
-  private static checkYoutube(url: string) {
+  private static checkYoutube(url: string): boolean {
     const youtubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.be)\/.+$/;
     return youtubeRegex.test(url);
   }
@@ -55,56 +98,112 @@ export default class ExtensionBridge {
   }
 
   static async responsePageContent() {
-    const url = location.href;
-    const category = this.getCategory(url);
-    const content = await this._getContent(url, category);
-
-    Runtime.onMessage(BRIDGE_MESSAGE_TYPES.PAGE_CONTENT, async (_, __, sendResponse) => {
-      sendResponse({ content, category });
-      return true;
-    });
+    try {
+      const url = location.href;
+      const category = this.getCategory(url);
+      const content = await this._getContent(url, category);
+
+      Runtime.onMessage(BRIDGE_MESSAGE_TYPES.PAGE_CONTENT, async (_, __, sendResponse) => {
+        try {
+          sendResponse({ content, category });
+          return true;
+        } catch (error) {
+          throw new ExtensionError('Failed to send page content response', ExtensionErrorCode.CONTENT_ERROR, error);
+        }
+      });
+    } catch (error) {
+      throw new ExtensionError('Failed to process page content response', ExtensionErrorCode.CONTENT_ERROR, error);
+    }
   }
 
   private static async _getContent(url: string, category: Category) {
-    if (category === 'youtube') return await this._getContentFromYoutube(url);
-    return this._getContentFromWeb();
+    try {
+      if (category === 'youtube') return await this._getContentFromYoutube(url);
+      return this._getContentFromWeb();
+    } catch (error) {
+      throw new ExtensionError('Failed to get content', ExtensionErrorCode.CONTENT_ERROR, error);
+    }
   }
 
   private static async _getContentFromYoutube(url: string) {
-    const transcripts = await YoutubeTranscript.fetchTranscript(url);
-    return transcripts.map(transcript => transcript.text).join('\n');
+    try {
+      const transcripts = await YoutubeTranscript.fetchTranscript(url);
+      return transcripts.map(transcript => transcript.text).join('\n');
+    } catch (error) {
+      throw new ExtensionError('Failed to get YouTube transcript', ExtensionErrorCode.YOUTUBE_ERROR, error);
+    }
   }
 
   private static _getContentFromWeb() {
-    return document.body.innerText;
+    try {
+      return document.body.innerText;
+    } catch (error) {
+      throw new ExtensionError('Failed to get web content', ExtensionErrorCode.CONTENT_ERROR, error);
+    }
   }
 
-  static requestRefetchTheMemos() {
-    return chrome.runtime.sendMessage(EXTENSION.id, {
-      type: BRIDGE_MESSAGE_TYPES.REFETCH_THE_MEMO_LIST,
-    });
+  static async requestRefetchTheMemos() {
+    try {
+      return await chrome.runtime.sendMessage(EXTENSION.id, {
+        type: BRIDGE_MESSAGE_TYPES.REFETCH_THE_MEMO_LIST,
+      });
+    } catch (error) {
+      throw new ExtensionError('Failed to request memo list refresh', ExtensionErrorCode.COMMUNICATION_ERROR, error);
+    }
   }
 
   static responseRefetchTheMemos(callbackFn: () => void) {
-    return Runtime.onMessageExternal(BRIDGE_MESSAGE_TYPES.REFETCH_THE_MEMO_LIST, callbackFn);
+    try {
+      return Runtime.onMessageExternal(BRIDGE_MESSAGE_TYPES.REFETCH_THE_MEMO_LIST, callbackFn);
+    } catch (error) {
+      throw new ExtensionError(
+        'Failed to respond to memo list refresh request',
+        ExtensionErrorCode.RUNTIME_ERROR,
+        error,
+      );
+    }
   }
 
-  static requestUpdateSidePanel() {
-    return Runtime.sendMessage(BRIDGE_MESSAGE_TYPES.UPDATE_SIDE_PANEL);
+  static async requestUpdateSidePanel() {
+    try {
+      return await Runtime.sendMessage(BRIDGE_MESSAGE_TYPES.UPDATE_SIDE_PANEL);
+    } catch (error) {
+      throw new ExtensionError('Failed to request side panel update', ExtensionErrorCode.COMMUNICATION_ERROR, error);
+    }
   }
 
   static responseUpdateSidePanel(callbackFn: Parameters<typeof Runtime.onMessage>[1]) {
-    return Runtime.onMessage(BRIDGE_MESSAGE_TYPES.UPDATE_SIDE_PANEL, callbackFn);
+    try {
+      return Runtime.onMessage(BRIDGE_MESSAGE_TYPES.UPDATE_SIDE_PANEL, callbackFn);
+    } catch (error) {
+      throw new ExtensionError(
+        'Failed to respond to side panel update request',
+        ExtensionErrorCode.RUNTIME_ERROR,
+        error,
+      );
+    }
   }
 
-  static requestGetExtensionManifest(callbackFn: (response: chrome.runtime.Manifest) => void) {
-    chrome.runtime.sendMessage(EXTENSION.id, { type: BRIDGE_MESSAGE_TYPES.GET_EXTENSION_MANIFEST }, callbackFn);
+  static async requestGetExtensionManifest(callbackFn: (response: chrome.runtime.Manifest) => void) {
+    try {
+      await chrome.runtime.sendMessage(EXTENSION.id, { type: BRIDGE_MESSAGE_TYPES.GET_EXTENSION_MANIFEST }, callbackFn);
+    } catch (error) {
+      throw new ExtensionError('Failed to request extension manifest', ExtensionErrorCode.RUNTIME_ERROR, error);
+    }
   }
 
   static responseGetExtensionManifest() {
-    const manifest = chrome.runtime.getManifest();
-    Runtime.onMessageExternal(BRIDGE_MESSAGE_TYPES.GET_EXTENSION_MANIFEST, (_, __, sendResponse) =>
-      sendResponse(manifest),
-    );
+    try {
+      const manifest = chrome.runtime.getManifest();
+      Runtime.onMessageExternal(BRIDGE_MESSAGE_TYPES.GET_EXTENSION_MANIFEST, (_, __, sendResponse) =>
+        sendResponse(manifest),
+      );
+    } catch (error) {
+      throw new ExtensionError(
+        'Failed to respond to extension manifest request',
+        ExtensionErrorCode.RUNTIME_ERROR,
+        error,
+      );
+    }
   }
 }
@@ -0,0 +1,26 @@
+import { Category } from './constant';
+
+export class ExtensionError extends Error {
+  constructor(
+    message: string,
+    public code: ExtensionErrorCode,
+    public originalError?: unknown,
+  ) {
+    super(message);
+    this.name = 'ExtensionError';
+  }
+}
+
+export enum ExtensionErrorCode {
+  COMMUNICATION_ERROR = 'COMMUNICATION_ERROR',
+  PERMISSION_ERROR = 'PERMISSION_ERROR',
+  CONTENT_ERROR = 'CONTENT_ERROR',
+  RUNTIME_ERROR = 'RUNTIME_ERROR',
+  TAB_ERROR = 'TAB_ERROR',
+  YOUTUBE_ERROR = 'YOUTUBE_ERROR',
+}
+
+export interface PageContent {
+  content: string;
+  category: Category;
+}
@@ -0,0 +1 @@
+export const delay = () => new Promise(resolve => setTimeout(resolve, 3000));
@@ -10,3 +10,4 @@ export * from './String';
 export * from './Supabase';
 export * from './Tailwind';
 export * from './Url';
+export * from './Time';
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		export const delay = () => new Promise(resolve => setTimeout(resolve, 3000));