Add error handling, enhance syncing, and refactor deletion logic

- Introduce new error messages for syncing and book deletion in `en.json`.
- Update `DeleteBook` to support local-only deletion and synced book management.
- Refine offline/online behavior with `deleteLocalToo` checkbox and update related state handling.
- Extend repository and IPC methods to handle optional IDs for updates.
- Add `SyncQueueContext` for queueing offline changes and improving synchronization workflows.
- Enhance refined text generation logic in `DraftCompanion` and `GhostWriter` components.
- Replace PUT with PATCH for world updates to align with API expectations.
- Streamline `AlertBox` by integrating dynamic translation keys for deletion prompts.

components/book/settings/BasicInformationSetting.tsx

@@ -68,7 +68,7 @@ function BasicInformationSetting(props: any, ref: any) {
                 },
                 params: {
                     lang: lang,
-                    plateforme: 'web',
+                    plateforme: 'desktop',
                 },
                 data: formData,
                 responseType: 'arraybuffer'

components/book/settings/DeleteBook.tsx

@@ -9,6 +9,7 @@ import AlertBox from "@/components/AlertBox";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
 import {BooksSyncContext, BooksSyncContextProps} from "@/context/BooksSyncContext";
 import {SyncedBook} from "@/lib/models/SyncedBook";
+import {useTranslations} from "next-intl";
 
 interface DeleteBookProps {
     bookId: string;
@@ -19,10 +20,16 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
     const {lang} = useContext<LangContextProps>(LangContext)
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
     const [showConfirmBox, setShowConfirmBox] = useState<boolean>(false);
+    const [deleteLocalToo, setDeleteLocalToo] = useState<boolean>(false);
     const {errorMessage} = useContext<AlertContextProps>(AlertContext)
-    const {serverOnlyBooks,setServerOnlyBooks,localOnlyBooks,setLocalOnlyBooks} = useContext<BooksSyncContextProps>(BooksSyncContext);
-    
+    const {serverOnlyBooks,setServerOnlyBooks,localOnlyBooks,setLocalOnlyBooks,localSyncedBooks,setLocalSyncedBooks,setServerSyncedBooks} = useContext<BooksSyncContextProps>(BooksSyncContext);
+    const t = useTranslations('deleteBook');
+
+    const ifLocalOnlyBook: SyncedBook | undefined = localOnlyBooks.find((book: SyncedBook): boolean => book.id === bookId);
+    const ifSyncedBook: SyncedBook | undefined = localSyncedBooks.find((book: SyncedBook): boolean => book.id === bookId);
+
     function handleConfirmation(): void {
+        setDeleteLocalToo(false);
         setShowConfirmBox(true);
     }
 
@@ -30,9 +37,8 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
         try {
             let response: boolean;
             const deleteData = { id: bookId };
-            const ifLocalBook: SyncedBook | undefined = localOnlyBooks.find((book: SyncedBook): boolean => book.id === bookId);
 
-            if (isCurrentlyOffline() || ifLocalBook) {
+            if (isCurrentlyOffline() || ifLocalOnlyBook) {
                 response = await window.electron.invoke<boolean>('db:book:delete', deleteData);
             } else {
                 response = await System.authDeleteToServer<boolean>(
@@ -41,11 +47,23 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
                     session.accessToken,
                     lang
                 );
+                // If synced book and user wants to delete local too
+                if (response && ifSyncedBook && deleteLocalToo) {
+                    await window.electron.invoke<boolean>('db:book:delete', deleteData);
+                }
             }
             if (response) {
                 setShowConfirmBox(false);
-                if (ifLocalBook) {
+                if (ifLocalOnlyBook) {
                     setLocalOnlyBooks(localOnlyBooks.filter((b: SyncedBook): boolean => b.id !== bookId));
+                } else if (ifSyncedBook) {
+                    // Remove from synced lists
+                    setLocalSyncedBooks(localSyncedBooks.filter((b: SyncedBook): boolean => b.id !== bookId));
+                    setServerSyncedBooks((prev: SyncedBook[]): SyncedBook[] => prev.filter((b: SyncedBook): boolean => b.id !== bookId));
+                    // If not deleting local, move to localOnlyBooks
+                    if (!deleteLocalToo) {
+                        setLocalOnlyBooks([...localOnlyBooks, ifSyncedBook]);
+                    }
                 } else {
                     setServerOnlyBooks(serverOnlyBooks.filter((b: SyncedBook): boolean => b.id !== bookId));
                 }
@@ -54,7 +72,7 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
             if (e instanceof Error) {
                 errorMessage(e.message)
             } else {
-                errorMessage("Une erreur inconnue est survenue lors de la suppression du livre.");
+                errorMessage(t('errorUnknown'));
             }
         }
     }
@@ -67,10 +85,32 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
             </button>
             {
                 showConfirmBox && (
-                    <AlertBox title={'Suppression du livre'}
-                              message={'Vous être sur le point de supprimer votre livre définitivement.'} type={"danger"}
-                              onConfirm={handleDeleteBook} onCancel={() => setShowConfirmBox(false)}
-                              confirmText={'Supprimer'} cancelText={'Annuler'}/>
+                    <AlertBox title={t('title')}
+                              message={t('message')}
+                              type={"danger"}
+                              onConfirm={handleDeleteBook}
+                              onCancel={() => setShowConfirmBox(false)}
+                              confirmText={t('confirm')}
+                              cancelText={t('cancel')}>
+                        {ifSyncedBook && !isCurrentlyOffline() && (
+                            <div className="mt-4 p-3 bg-error/10 border border-error/30 rounded-lg">
+                                <label className="flex items-center gap-3 cursor-pointer">
+                                    <input
+                                        type="checkbox"
+                                        checked={deleteLocalToo}
+                                        onChange={(e) => setDeleteLocalToo(e.target.checked)}
+                                        className="w-5 h-5 accent-error cursor-pointer"
+                                    />
+                                    <span className="text-sm text-text-primary">
+                                        {t('deleteLocalToo')}
+                                    </span>
+                                </label>
+                                <p className="text-xs text-error mt-2">
+                                    {t('deleteLocalWarning')}
+                                </p>
+                            </div>
+                        )}
+                    </AlertBox>
                 )
             }
         </>

components/book/settings/world/WorldSetting.tsx

@@ -165,7 +165,7 @@ export function WorldSetting(props: any, ref: any) {
             if (isCurrentlyOffline() || book?.localBook) {
                 response = await window.electron.invoke<boolean>('db:book:world:update', worldData);
             } else {
-                response = await System.authPutToServer<boolean>('book/world/update', worldData, session.accessToken, lang);
+                response = await System.authPatchToServer<boolean>('book/world/update', worldData, session.accessToken, lang);
 
                 if (localSyncedBooks.find((syncedBook: SyncedBook): boolean => syncedBook.id === bookId)) {
                     addToQueue('db:book:world:update', worldData);