chore: keepalive

Author: mtdvlpr

nuxt.config.ts

@@ -19,6 +19,16 @@ export default defineNuxtConfig({
     jwpubKey: process.env.JWPUB_KEY,
   },
   compatibilityDate: "2026-01-15",
+  routeRules: {
+    "/api/outlines": {
+      // Mark as long-running operation
+      cache: false,
+    },
+    "/api/export": {
+      // Mark as long-running operation
+      cache: false,
+    },
+  },
   piniaPluginPersistedstate: {
     storage: "localStorage",
     debug: true,

server/api/outlines.post.ts

@@ -1,36 +1,50 @@
+import { type KeepAlive, withKeepAlive } from "../utils/keepalive";
+
 export default defineEventHandler(async (event) => {
-  event.node.req.setTimeout(1 * 60 * 60 * 1000);
-  console.log("Getting outlines...");
-  const database = await processFileUpload(event, {
-    maxSize: 256 * 1024 * 1024,
-    processor: async (fileStream) => {
-      console.log("Processing file stream...");
-      return await getJWPUBDatabase(fileStream);
-    },
-  });
+  return withKeepAlive(
+    event,
+    async (keepalive: KeepAlive) => {
+      keepalive.progress("Starting file upload processing...");
 
-  const outlines = queryDatabase<{ Title: string }>(
-    database,
-    "SELECT Title FROM Document",
-  );
-  const htmlOutlines = await parseJWPUB(database);
-  const parsedOutlines = outlines
-    .map((outline) => {
-      const [number, ...title] = outline.Title.split(". ");
-      return {
-        number: parseInt(number?.trim() ?? "0"),
-        title: title.join(". "),
-      };
-    })
-    .filter((outline) => outline.number > 0);
+      const database = await processFileUpload(event, {
+        maxSize: 256 * 1024 * 1024,
+        processor: async (fileStream) => {
+          keepalive.progress("Extracting database from JWPUB file...");
+          return await getJWPUBDatabase(fileStream);
+        },
+      });
+
+      keepalive.progress("Database extracted, querying documents...");
+      const outlines = queryDatabase<{ Title: string }>(
+        database,
+        "SELECT Title FROM Document",
+      );
 
-  const match =
-    htmlOutlines.length === parsedOutlines.length &&
-    htmlOutlines.every(
-      (htmlOutline, index) =>
-        htmlOutline.number === parsedOutlines[index]?.number &&
-        htmlOutline.title === parsedOutlines[index]?.title,
-    );
+      keepalive.progress("Parsing JWPUB content...");
+      const htmlOutlines = await parseJWPUB(database);
 
-  return match ? htmlOutlines : parsedOutlines;
+      keepalive.progress("Processing outlines...");
+      const parsedOutlines = outlines
+        .map((outline) => {
+          const [number, ...title] = outline.Title.split(". ");
+          return {
+            number: parseInt(number?.trim() ?? "0"),
+            title: title.join(". "),
+          };
+        })
+        .filter((outline) => outline.number > 0);
+
+      const match =
+        htmlOutlines.length === parsedOutlines.length &&
+        htmlOutlines.every(
+          (htmlOutline, index) =>
+            htmlOutline.number === parsedOutlines[index]?.number &&
+            htmlOutline.title === parsedOutlines[index]?.title,
+        );
+
+      keepalive.progress("Outlines processed successfully");
+      return match ? htmlOutlines : parsedOutlines;
+    },
+    "Processing JWPUB file upload...",
+  );
 });

server/utils/keepalive.ts

@@ -0,0 +1,66 @@
+import type { H3Event } from "h3";
+
+/**
+ * Creates a keep-alive mechanism to prevent inactivity timeouts during long operations.
+ * Logs progress messages at regular intervals.
+ */
+export class KeepAlive {
+  private interval: NodeJS.Timeout | null = null;
+  private lastLog = 0;
+  private startTime = Date.now();
+
+  constructor(
+    private event: H3Event,
+    private intervalMs = 10000,
+  ) {}
+
+  /**
+   * Log progress update
+   */
+  progress(message: string) {
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1000);
+    console.log(`[KeepAlive] ${message} (${elapsed}s elapsed)`);
+  }
+
+  /**
+   * Start sending keep-alive signals
+   */
+  start(message = "Processing...") {
+    console.log(`[KeepAlive] Started: ${message}`);
+    this.lastLog = Date.now();
+
+    this.interval = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - this.startTime) / 1000);
+      console.log(`[KeepAlive] Still processing... (${elapsed}s elapsed)`);
+    }, this.intervalMs);
+  }
+
+  /**
+   * Stop the keep-alive mechanism
+   */
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1000);
+    console.log(`[KeepAlive] Completed (${elapsed}s total)`);
+  }
+}
+
+/**
+ * Creates a keep-alive instance for an event handler.
+ * Automatically starts logging and cleans up when the promise settles.
+ */
+export function withKeepAlive<T>(
+  event: H3Event,
+  operation: (keepalive: KeepAlive) => Promise<T>,
+  startMessage = "Processing request...",
+): Promise<T> {
+  const keepalive = new KeepAlive(event);
+  keepalive.start(startMessage);
+
+  return operation(keepalive).finally(() => {
+    keepalive.stop();
+  });
+}