fix issue with empty fields

.gitignore

···
 .DS_Store
 
 # Node modules (if any)
-node_modules/
+node_modules/
+
+# test data
+testdata/

CLAUDE.md

···
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a web service that converts reading data between Storygraph and Goodreads CSV formats, hosted on Val Town. It provides bidirectional conversion with optional Goodreads API enrichment.
+
+## Development Commands
+
+**Quality Check (run before deployment):**
+```bash
+deno task quality
+```
+This runs formatting, linting with fixes, type checking, and all tests.
+
+**Deploy to Val Town:**
+```bash
+deno task deploy
+```
+Runs quality checks first, then pushes to Val Town.
+
+**Individual Commands:**
+- `deno task test` - Run all tests with necessary permissions
+- `deno task fmt` - Format code
+- `deno task lint` - Lint and fix issues
+- `deno task check` - Type check all TypeScript files
+
+**Run a single test:**
+```bash
+deno test --allow-net --allow-read --allow-import backend/utils/converter.test.ts
+```
+
+## Architecture
+
+The codebase follows a clean separation pattern:
+
+- **backend/**: Hono server and business logic
+  - `index.ts`: Main entry point, handles HTTP routes and SSE streaming
+  - `utils/`: Core conversion logic, file validation, and Goodreads API integration
+  
+- **frontend/**: React SPA with no build step
+  - Direct ESM imports from esm.sh
+  - TailwindCSS via Twind
+  - Server-Sent Events for progress tracking
+  
+- **shared/**: TypeScript interfaces used by both frontend and backend
+
+## Key Technical Considerations
+
+**Platform:** This runs on Val Town using Deno (not Node.js). Use Val Town's utilities like `serveFile`, `readFile`, and blob storage.
+
+**Testing:** All business logic has comprehensive unit tests. Tests use dependency injection patterns - external services are mocked. Test files are co-located with source files (`.test.ts`).
+
+**Security:** The file validator enforces strict limits on file types, sizes (1MB max), and content patterns. All user input is validated before processing.
+
+**API Integration:** Goodreads API calls are rate-limited and cached. The enricher gracefully handles API failures and continues with basic conversion.
+
+**Progress Tracking:** Long-running conversions use Server-Sent Events to stream progress updates to the frontend.
+
+## Val Town Specifics
+
+- Use `@std/` for Deno standard library imports
+- Blob storage is used for temporary file handling with 24-hour TTL
+- The cleanup cron job runs daily to remove expired files
+- Deploy with `vt push` after running quality checks

storygraph-to-goodreads/backend/index.ts

···
 import {
   convertGoodreadsToStorygraph,
   convertStorygraphToGoodreads,
-  convertStorygraphToGoodreadsEnriched,
   generateCSV,
   parseCSV,
 } from "./utils/converter.ts";
···
     const formData = await c.req.formData();
     const file = formData.get("file") as File;
     const direction = formData.get("direction") as ConversionDirection;
-    const enrichWithGoodreads = formData.get("enrichWithGoodreads") === "true";
 
     if (!file) {
       return c.json({ error: "No file provided" }, 400);
···
     let filename: string;
 
     if (direction === "storygraph-to-goodreads") {
-      if (enrichWithGoodreads) {
-        console.log("🔍 Using Goodreads enrichment for better matching...");
-        const goodreadsBooks = await convertStorygraphToGoodreadsEnriched(
-          inputData,
-        );
-        convertedData = goodreadsBooks.map((book) =>
-          book as unknown as Record<string, string>
-        );
-        filename = "goodreads_library_export_enriched.csv";
-      } else {
-        const goodreadsBooks = convertStorygraphToGoodreads(inputData);
-        convertedData = goodreadsBooks.map((book) =>
-          book as unknown as Record<string, string>
-        );
-        filename = "goodreads_library_export.csv";
-      }
+      console.log("🔍 Using Goodreads enrichment for better matching...");
+      const goodreadsBooks = await convertStorygraphToGoodreads(
+        inputData,
+      );
+      convertedData = goodreadsBooks.map((book) =>
+        book as unknown as Record<string, string>
+      );
+      filename = "goodreads_library_export.csv";
       headers = [
         "Book Id",
         "Title",
···
         filename,
         createdAt: new Date().toISOString(),
         direction,
-        enriched: enrichWithGoodreads,
       }),
     );
 
···
       downloadUrl: `/api/download/${blobKey}`,
       filename,
       recordCount: convertedData.length,
-      enriched: enrichWithGoodreads,
     });
   } catch (error) {
     console.error("Conversion error:", error);
···
     const formData = await c.req.formData();
     const file = formData.get("file") as File;
     const direction = formData.get("direction") as ConversionDirection;
-    const enrichWithGoodreads = formData.get("enrichWithGoodreads") === "true";
 
     if (!file) {
       return c.json({ error: "No file provided" }, 400);
···
         let filename: string;
 
         if (direction === "storygraph-to-goodreads") {
-          if (enrichWithGoodreads) {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                event: "enrichment-start",
-                stage: "enriching",
-                message:
-                  "Starting Goodreads enrichment for better BookHive compatibility...",
-                totalBooks: inputData.length,
-                id: eventId++,
-              }),
-            });
-
-            // Use enrichment with progress callback
-            const { enrichStorygraphWithGoodreads } = await import(
-              "./utils/goodreads-enricher.ts"
-            );
-            const enrichedBooks = await enrichStorygraphWithGoodreads(
-              inputData,
-              async (current, total, bookTitle) => {
-                await stream.writeSSE({
-                  data: JSON.stringify({
-                    event: "enrichment-progress",
-                    stage: "enriching",
-                    message: `Enriching book ${current}/${total}`,
-                    currentBook: bookTitle,
-                    progress: Math.round((current / total) * 100),
-                    current,
-                    total,
-                    id: eventId++,
-                  }),
-                });
-              },
-            );
+          await stream.writeSSE({
+            data: JSON.stringify({
+              event: "enrichment-start",
+              stage: "enriching",
+              message:
+                "Starting Goodreads enrichment for better BookHive compatibility...",
+              totalBooks: inputData.length,
+              id: eventId++,
+            }),
+          });
 
-            await stream.writeSSE({
-              data: JSON.stringify({
-                event: "enrichment-complete",
-                stage: "converting",
-                message:
-                  "Goodreads enrichment completed, converting to Goodreads format...",
-                id: eventId++,
-              }),
-            });
+          // Use enrichment with progress callback
+          const enrichedBooks = await convertStorygraphToGoodreads(
+            inputData,
+            async (current, total, bookTitle) => {
+              await stream.writeSSE({
+                data: JSON.stringify({
+                  event: "enrichment-progress",
+                  stage: "enriching",
+                  message: `Enriching book ${current}/${total}`,
+                  currentBook: bookTitle,
+                  progress: Math.round((current / total) * 100),
+                  current,
+                  total,
+                  id: eventId++,
+                }),
+              });
+            },
+          );
 
-            // Convert enriched books to Goodreads format
-            convertedData = enrichedBooks.map((book) =>
-              book as unknown as Record<string, string>
-            );
-            filename = "goodreads_library_export_enriched.csv";
-            successCount = enrichedBooks.length;
-          } else {
-            await stream.writeSSE({
-              data: JSON.stringify({
-                event: "conversion-start",
-                stage: "converting",
-                message: "Converting to Goodreads format...",
-                id: eventId++,
-              }),
-            });
+          await stream.writeSSE({
+            data: JSON.stringify({
+              event: "enrichment-complete",
+              stage: "converting",
+              message:
+                "Goodreads enrichment completed, converting to Goodreads format...",
+              id: eventId++,
+            }),
+          });
 
-            const goodreadsBooks = convertStorygraphToGoodreads(inputData);
-            convertedData = goodreadsBooks.map((book) =>
-              book as unknown as Record<string, string>
-            );
-            filename = "goodreads_library_export.csv";
-            successCount = goodreadsBooks.length;
-          }
+          // Convert enriched books to Goodreads format
+          convertedData = enrichedBooks.map((book) =>
+            book as unknown as Record<string, string>
+          );
+          filename = "goodreads_library_export.csv";
+          successCount = enrichedBooks.length;
 
           headers = [
             "Book Id",
···
             filename,
             createdAt: new Date().toISOString(),
             direction,
-            enriched: enrichWithGoodreads,
           }),
         );
 
···
               totalBooks: inputData.length,
               successCount,
               failedCount: failedBooks.length,
-              enriched: enrichWithGoodreads,
             },
             failedBooks,
             id: eventId++,

storygraph-to-goodreads/backend/utils/converter.test.ts

···
 } from "https://deno.land/std@0.208.0/assert/mod.ts";
 import {
   convertGoodreadsToStorygraph,
-  convertStorygraphToGoodreads,
+  convertStorygraphToGoodreadsSimple,
   generateCSV,
   parseCSV,
   parseISBN,
···
     },
   ];
 
-  const result = convertStorygraphToGoodreads(storygraphBooks);
+  const result = convertStorygraphToGoodreadsSimple(storygraphBooks);
 
   assertEquals(result.length, 1);
   assertEquals(result[0]["Title"], "The Martian");
···
     },
   ];
 
-  const result = convertStorygraphToGoodreads(storygraphBooks);
+  const result = convertStorygraphToGoodreadsSimple(storygraphBooks);
 
   assertEquals(result[0]["Author"], "Terry Pratchett");
   assertEquals(result[0]["Additional Authors"], "Neil Gaiman, Someone Else");
···
     },
   ];
 
-  const result = convertStorygraphToGoodreads(storygraphBooks);
+  const result = convertStorygraphToGoodreadsSimple(storygraphBooks);
 
   assertEquals(result[0]["Exclusive Shelf"], "to-read");
   assertEquals(result[0]["Date Read"], "");
···
     },
   ];
 
-  const result = convertStorygraphToGoodreads(storygraphBooks);
+  const result = convertStorygraphToGoodreadsSimple(storygraphBooks);
 
   assertEquals(result[0]["Exclusive Shelf"], "currently-reading");
 });
···
   });
 });
 
+Deno.test("convertStorygraphToGoodreads - should map all fields correctly", () => {
+  const storygraphBooks = [
+    {
+      Title: "Test Book",
+      Authors: "Primary Author",
+      Contributors: "Contributor One",
+      "ISBN/UID": "9781234567890",
+      Format: "paperback",
+      "Read Status": "read",
+      "Date Added": "2023/01/15",
+      "Last Date Read": "2023/02/01",
+      "Dates Read": "2023/02/01",
+      "Read Count": "2",
+      "Star Rating": "4.5",
+      Review: "Great book!",
+      "Owned?": "Yes",
+    },
+  ];
+
+  const result = convertStorygraphToGoodreadsSimple(storygraphBooks);
+
+  assertEquals(result.length, 1);
+  const book = result[0];
+
+  // Core identification
+  assertEquals(book["Book Id"], "1");
+  assertEquals(book["Title"], "Test Book");
+  assertEquals(book["Author"], "Primary Author");
+  assertEquals(book["Author l-f"], ""); // Empty as expected
+  assertEquals(book["Additional Authors"], "Contributor One");
+
+  // ISBN fields
+  assertEquals(book["ISBN"], "123456789X"); // ISBN-10 converted from ISBN-13 (X = check digit 10)
+  assertEquals(book["ISBN13"], "9781234567890");
+
+  // Ratings
+  assertEquals(book["My Rating"], "4.5");
+  assertEquals(book["Average Rating"], ""); // Empty as expected
+
+  // Publication info (empty as expected)
+  assertEquals(book["Publisher"], "");
+  assertEquals(book["Number of Pages"], "");
+  assertEquals(book["Year Published"], "");
+  assertEquals(book["Original Publication Year"], "");
+
+  // Format
+  assertEquals(book["Binding"], "Paperback");
+
+  // Dates
+  assertEquals(book["Date Read"], "2023/02/01");
+  assertEquals(book["Date Added"], "2023/01/15");
+
+  // Shelves and status
+  assertEquals(book["Bookshelves"], "read");
+  assertEquals(book["Bookshelves with positions"], ""); // Empty as expected
+  assertEquals(book["Exclusive Shelf"], "read");
+
+  // Reviews and notes
+  assertEquals(book["My Review"], "Great book!");
+  assertEquals(book["Spoiler"], ""); // Empty as expected
+  assertEquals(book["Private Notes"], ""); // Empty as expected
+
+  // Ownership and reading
+  assertEquals(book["Read Count"], "2");
+  assertEquals(book["Owned Copies"], "1"); // "Yes" -> "1"
+});
+
 Deno.test("convertStorygraphToGoodreads - should handle missing optional fields", () => {
   const storygraphBooks = [
     {
···
     },
   ];
 
-  const result = convertStorygraphToGoodreads(storygraphBooks);
+  const result = convertStorygraphToGoodreadsSimple(storygraphBooks);
 
   assertEquals(result[0]["Title"], "Minimal Book");
   assertEquals(result[0]["Author"], "Minimal Author");

storygraph-to-goodreads/backend/utils/converter.ts

···
   }
 }
 
-export function convertStorygraphToGoodreads(
+export function convertGoodreadsToStorygraph(
+  goodreadsBooks: Record<string, string>[],
+): StorygraphBook[] {
+  return goodreadsBooks.map((book) => {
+    const authors = [book.Author, book["Additional Authors"]]
+      .filter(Boolean)
+      .join(", ");
+
+    const { isbn } = parseISBN(book.ISBN13 || book.ISBN);
+
+    return {
+      "Title": book.Title || "",
+      "Authors": authors,
+      "Contributors": "", // Empty as specified
+      "ISBN/UID": isbn,
+      "Format": mapFormat(book.Binding, "goodreads-to-storygraph"),
+      "Read Status": book["Exclusive Shelf"] || "to-read",
+      "Date Added": convertDate(book["Date Added"], "storygraph"),
+      "Last Date Read": convertDate(book["Date Read"], "storygraph"),
+      "Dates Read": convertDate(book["Date Read"], "storygraph"),
+      "Read Count": book["Read Count"] || "0",
+      "Moods": "", // Empty as specified
+      "Pace": "", // Empty as specified
+      "Character- or Plot-Driven?": "", // Empty as specified
+      "Strong Character Development?": "", // Empty as specified
+      "Loveable Characters?": "", // Empty as specified
+      "Diverse Characters?": "", // Empty as specified
+      "Flawed Characters?": "", // Empty as specified
+      "Star Rating": book["My Rating"] || "0",
+      "Review": book["My Review"] || "",
+      "Content Warnings": "", // Empty as specified
+      "Content Warning Description": "", // Empty as specified
+      "Tags": "", // Empty as specified
+      "Owned?": "No", // Empty as specified
+    };
+  });
+}
+
+// Simple sync version for testing (no enrichment)
+export function convertStorygraphToGoodreadsSimple(
   storygraphBooks: Record<string, string>[],
 ): GoodreadsBook[] {
   return storygraphBooks.map((book, index) => {
···
 
     const { isbn, isbn13 } = parseISBN(book["ISBN/UID"]);
 
+    // Map Storygraph's Owned? field to Goodreads format
+    const ownedCopies = book["Owned?"]?.toLowerCase() === "yes" ? "1" : "0";
+
+    // Use Read Status for Bookshelves
+    const readStatus = book["Read Status"] || "to-read";
+
     return {
       "Book Id": (index + 1).toString(),
       "Title": book.Title || "",
···
       "My Rating": book["Star Rating"] || "0",
       "Average Rating": "", // Empty as specified
       "Publisher": "", // Empty as specified
-      "Binding": mapFormat(book.Format, "storygraph-to-goodreads"),
+      "Binding": mapFormat(book.Format || "", "storygraph-to-goodreads"),
       "Number of Pages": "", // Empty as specified
       "Year Published": "", // Empty as specified
       "Original Publication Year": "", // Empty as specified
-      "Date Read": convertDate(book["Last Date Read"], "goodreads"),
-      "Date Added": convertDate(book["Date Added"], "goodreads"),
-      "Bookshelves": "", // Empty as specified
+      "Date Read": convertDate(book["Last Date Read"] || "", "goodreads"),
+      "Date Added": convertDate(book["Date Added"] || "", "goodreads"),
+      "Bookshelves": readStatus,
       "Bookshelves with positions": "", // Empty as specified
-      "Exclusive Shelf": book["Read Status"] || "to-read",
+      "Exclusive Shelf": readStatus,
       "My Review": book.Review || "",
       "Spoiler": "", // Empty as specified
       "Private Notes": "", // Empty as specified
       "Read Count": book["Read Count"] || "0",
-      "Owned Copies": "0", // Empty as specified
+      "Owned Copies": ownedCopies,
     };
   });
 }
 
-export function convertGoodreadsToStorygraph(
-  goodreadsBooks: Record<string, string>[],
-): StorygraphBook[] {
-  return goodreadsBooks.map((book) => {
-    const authors = [book.Author, book["Additional Authors"]]
-      .filter(Boolean)
-      .join(", ");
-
-    const { isbn } = parseISBN(book.ISBN13 || book.ISBN);
-
-    return {
-      "Title": book.Title || "",
-      "Authors": authors,
-      "Contributors": "", // Empty as specified
-      "ISBN/UID": isbn,
-      "Format": mapFormat(book.Binding, "goodreads-to-storygraph"),
-      "Read Status": book["Exclusive Shelf"] || "to-read",
-      "Date Added": convertDate(book["Date Added"], "storygraph"),
-      "Last Date Read": convertDate(book["Date Read"], "storygraph"),
-      "Dates Read": convertDate(book["Date Read"], "storygraph"),
-      "Read Count": book["Read Count"] || "0",
-      "Moods": "", // Empty as specified
-      "Pace": "", // Empty as specified
-      "Character- or Plot-Driven?": "", // Empty as specified
-      "Strong Character Development?": "", // Empty as specified
-      "Loveable Characters?": "", // Empty as specified
-      "Diverse Characters?": "", // Empty as specified
-      "Flawed Characters?": "", // Empty as specified
-      "Star Rating": book["My Rating"] || "0",
-      "Review": book["My Review"] || "",
-      "Content Warnings": "", // Empty as specified
-      "Content Warning Description": "", // Empty as specified
-      "Tags": "", // Empty as specified
-      "Owned?": "No", // Empty as specified
-    };
-  });
-}
-
-export async function convertStorygraphToGoodreadsEnriched(
+export async function convertStorygraphToGoodreads(
   storygraphBooks: Record<string, string>[],
   onProgress?: (current: number, total: number, book: string) => void,
 ): Promise<GoodreadsBook[]> {
···
       : [];
     const additionalAuthors = [...originalAuthors.slice(1), ...contributors]
       .filter(Boolean);
+
+    // Map Storygraph's Owned? field to Goodreads format
+    const ownedCopies = book["Owned?"]?.toLowerCase() === "yes" ? "1" : "0";
+
+    // Use Read Status for Bookshelves
+    const readStatus = book["Read Status"] || "to-read";
 
     return {
       "Book Id": book["Book Id"] || "", // Use Goodreads Book ID if available
···
       "Original Publication Year": "", // Still empty as we don't get this from Goodreads search
       "Date Read": convertDate(book["Last Date Read"] || "", "goodreads"),
       "Date Added": convertDate(book["Date Added"] || "", "goodreads"),
-      "Bookshelves": "",
+      "Bookshelves": readStatus,
       "Bookshelves with positions": "",
-      "Exclusive Shelf": book["Read Status"] || "to-read",
+      "Exclusive Shelf": readStatus,
       "My Review": book.Review || "",
       "Spoiler": "",
       "Private Notes": "",
       "Read Count": book["Read Count"] || "0",
-      "Owned Copies": "0",
+      "Owned Copies": ownedCopies,
     };
   });
 }

storygraph-to-goodreads/backend/utils/goodreads-enricher.ts

···
   const normalizedTitle = normalizeTitle(book.Title || "");
   const normalizedAuthor = normalizeAuthor(book.Authors || "");
 
-  // Create base enriched book with normalized data
+  // Create base enriched book preserving ALL original Storygraph data
   const enrichedBook: Record<string, string> = {
-    ...book,
+    ...book, // Keep all original fields including Title, Authors, Star Rating, etc.
     "Book Id": "", // Leave empty as requested
-    "Title": normalizedTitle,
-    "Author": normalizedAuthor,
     "Author l-f": "", // Will be filled if we get Goodreads data
     "Additional Authors": "", // Will be filled if we get Goodreads data
   };
···
   const goodreadsResult = await searchGoodreads(normalizedTitle);
 
   if (goodreadsResult) {
-    // CRITICAL: Use the FULL title (with series info) to match BookHive's rawTitle field
-    // BookHive stores rawTitle = result.title (full) and title = result.bookTitleBare (clean)
-    // For CSV imports to match, we need to use the FULL title that BookHive stores as rawTitle
+    // ONLY update the specific fields we need from Goodreads
+    // This preserves all original Storygraph data while adding Goodreads enrichment
     enrichedBook["Book Id"] = goodreadsResult.bookId || "";
-    enrichedBook["Title"] = goodreadsResult.title; // Use FULL title (matches BookHive's rawTitle)
-    enrichedBook["Author"] = goodreadsResult.author.name || normalizedAuthor; // Use Goodreads author
+    enrichedBook["Title"] = goodreadsResult.title; // Use FULL title with series info
+    enrichedBook["Author"] = goodreadsResult.author.name || book.Authors || ""; // Use Goodreads author
     enrichedBook["Average Rating"] = goodreadsResult.avgRating || "";
     enrichedBook["Number of Pages"] = goodreadsResult.numPages?.toString() ||
       "";
···
       }`,
     );
     console.log(
-      `   📚 Using FULL title for BookHive compatibility: "${goodreadsResult.title}"`,
+      `   📚 Preserved all Storygraph data: Rating=${
+        book["Star Rating"]
+      }, Status=${book["Read Status"]}, Owned=${book["Owned?"]}`,
     );
   } else {
+    // No Goodreads match - just normalize the title and author
+    enrichedBook["Book Id"] = "";
+    enrichedBook["Title"] = normalizedTitle;
+    enrichedBook["Author"] = normalizedAuthor;
+    enrichedBook["Author l-f"] = "";
+    enrichedBook["Additional Authors"] = "";
     console.log(
-      `📝 Using normalized data for "${book.Title}" → "${normalizedTitle}"`,
+      `📝 No Goodreads match for "${book.Title}" - using normalized title: "${normalizedTitle}"`,
     );
   }
 

storygraph-to-goodreads/frontend/components/App.tsx

···
       const formData = new FormData();
       formData.append("file", file);
       formData.append("direction", direction);
-      formData.append(
-        "enrichWithGoodreads",
-        (direction === "storygraph-to-goodreads").toString(),
-      );
 
       const response = await fetch("/api/convert-stream", {
         method: "POST",
···
                   )}
                 </div>
 
-                {conversionState.stats.enriched && (
+                {direction === "storygraph-to-goodreads" && (
                   <div className="enrichment-badge">
                     🔍 Enhanced with Goodreads data for better BookHive
                     compatibility
···
             you own your data.
           </p>
           <p style={{ color: "#666", lineHeight: "1.6" }}>
-            The Goodreads enrichment feature dramatically improves import
-            success rates by normalizing book titles and fetching proper
-            Goodreads Book IDs that other platforms can recognize.
+            Storygraph conversions are automatically enhanced with Goodreads
+            data to dramatically improve import success rates by normalizing
+            book titles and fetching proper Goodreads Book IDs that other
+            platforms can recognize.
           </p>
         </div>