braid-text 0.2.79 → 0.2.81

package/index.js

@@ -197,6 +197,7 @@ function create_braid_text() {
                         disconnect()
                         connect()
                     }
+                    options.on_res?.(remote_result)
                     // on_error will call handle_error when connection drops
                 } catch (e) {
                     handle_error(e)
@@ -996,7 +997,7 @@ function create_braid_text() {
 
             await resource.db_delta(resource.doc.getPatchSince(v_before))
 
-            for (var [client, x] of post_commit_updates) client.my_subscribe(x)
+            await Promise.all(post_commit_updates.map(([client, x]) => client.my_subscribe(x)))
 
             return { change_count }
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.79",
+  "version": "0.2.81",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",

package/test/tests.js

@@ -1144,6 +1144,50 @@ runTest(
     'x'
 )
 
+runTest(
+    "test put awaits subscriber callbacks",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var order = []
+
+                // Subscribe with an async callback that takes some time
+                braid_text.get('/${key}', {
+                    subscribe: async (update) => {
+                        if (update.version?.[0]?.startsWith('test-v')) {
+                            order.push('subscriber-start')
+                            await new Promise(done => setTimeout(done, 50))
+                            order.push('subscriber-end')
+                        }
+                    }
+                })
+
+                // Wait for subscription to be established
+                await new Promise(done => setTimeout(done, 50))
+
+                // Put should await the subscriber callback
+                await braid_text.put('/${key}', {
+                    version: ['test-v-0'],
+                    parents: [],
+                    body: 'hello'
+                })
+                order.push('put-done')
+
+                // If put properly awaited, order should be: subscriber-start, subscriber-end, put-done
+                // If put didn't await, order would be: subscriber-start, put-done, subscriber-end
+                res.end(order.join(','))
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'subscriber-start,subscriber-end,put-done'
+)
+
 runTest(
     "test out-of-order PUTs",
     async () => {
@@ -1981,6 +2025,47 @@ runTest(
     'created locally'
 )
 
+runTest(
+    "test braid_text.sync on_res callback",
+    async () => {
+        var local_key = 'test-local-' + Math.random().toString(36).slice(2)
+        var remote_key = 'test-remote-' + Math.random().toString(36).slice(2)
+
+        // Create the remote resource first
+        var r = await braid_fetch(`/${remote_key}`, {
+            method: 'PUT',
+            body: 'remote content'
+        })
+        if (!r.ok) return 'put failed: ' + r.status
+
+        // Start sync with on_res callback and verify it gets called
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var ac = new AbortController()
+                var got_res = false
+
+                braid_text.sync('/${local_key}', new URL('http://localhost:8889/${remote_key}'), {
+                    signal: ac.signal,
+                    on_res: (response) => {
+                        got_res = response && typeof response.headers !== 'undefined'
+                    }
+                })
+
+                // Wait for sync to establish and on_res to be called
+                await new Promise(done => setTimeout(done, 200))
+
+                ac.abort()
+                res.end(got_res ? 'on_res called' : 'on_res not called')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'on_res called'
+)
+
 runTest(
     "test getting a binary update from a subscription",
     async () => {