Make storeDocumentHooks throw errors instead of silently ignoring them.

Make debounce function asynchronous and improve usage

Refactor the debounce function to return a Promise, enabling better handling in async workflows. Adjust related code to properly await hooks execution and error catching.

Simplify logic in storeDocumentHooks for improved readability and maintainability.

Author: janthurau

packages/server/src/Hocuspocus.ts

@@ -527,31 +527,17 @@ export class Hocuspocus {
   storeDocumentHooks(document: Document, hookPayload: onStoreDocumentPayload, immediately?: boolean) {
     return this.debouncer.debounce(
       `onStoreDocument-${document.name}`,
-      () => {
-        return this.hooks('onStoreDocument', hookPayload)
-          .then(() => {
-            this.hooks('afterStoreDocument', hookPayload).then(async () => {
-              // Remove document from memory.
-
-              if (document.getConnectionsCount() > 0) {
-                return
-              }
-
-              await this.unloadDocument(document)
-            })
-          })
-          .catch(error => {
-            console.error('Caught error during storeDocumentHooks', error)
+      async () => {
+        await this.hooks('onStoreDocument', hookPayload)
+        await this.hooks('afterStoreDocument', hookPayload)
 
-            if (error?.message) {
-              throw error
-            }
-          })
+        if (document.getConnectionsCount() === 0) {
+          await this.unloadDocument(document)
+        }
       },
       immediately ? 0 : this.configuration.debounce,
       this.configuration.maxDebounce,
     )
-
   }
 
   /**

packages/server/src/util/debounce.ts

@@ -5,7 +5,7 @@ export const useDebounce = () => {
     func: Function
   }> = new Map()
 
-  const debounce = (
+  const debounce = async (
     id: string,
     func: Function,
     debounce: number,
@@ -31,14 +31,18 @@ export const useDebounce = () => {
       return run()
     }
 
-    timers.set(id, {
-      start,
-      timeout: setTimeout(run, debounce),
-      func: run,
+    return new Promise((resolve, reject) => {
+      const runResolveReject = () => run().then(resolve).catch(reject)
+
+      timers.set(id, {
+        start,
+        timeout: setTimeout(runResolveReject, debounce),
+        func: () => runResolveReject,
+      })
     })
   }
 
-  const executeNow = (id: string) => {
+  const executeNow = async (id: string) => {
     const old = timers.get(id)
     if (old) {
       clearTimeout(old.timeout)