braid-text 0.2.84 → 0.2.86

package/index.js

@@ -108,7 +108,7 @@ function create_braid_text() {
 
             connect()
             async function connect() {
-                if (options.on_connect) options.on_connect()
+                if (options.on_pre_connect) await options.on_pre_connect()
 
                 if (closed) return
 
@@ -165,13 +165,18 @@ function create_braid_text() {
                         signal: ac.signal,
                         subscribe: update => {
                             update.signal = ac.signal
+                            update.dont_retry = true
                             braid_text.put(b, update).then((x) => {
-                                local_first_put()
-                                extend_fork_point(update)
+                                if (x.ok) {
+                                    local_first_put()
+                                    extend_fork_point(update)
+                                } else if (x.status === 401 || x.status === 403) {
+                                    options.on_unauthorized?.()
+                                } else throw new Error('failed to PUT: ' + x.status)
                             }).catch(e => {
                                 if (e.name === 'AbortError') {
                                     // ignore
-                                } else throw e
+                                } else handle_error(e)
                             })
                         }
                     }
@@ -187,7 +192,10 @@ function create_braid_text() {
                             await braid_text.put(a, update)
                             extend_fork_point(update)
                         },
-                        on_error: handle_error
+                        on_error: e => {
+                            options.on_disconnect?.()
+                            handle_error(e)
+                        }
                     }
                     // Handle case where remote doesn't exist yet - wait for local to create it
                     var remote_result = await braid_text.get(b, b_ops)
@@ -196,6 +204,7 @@ function create_braid_text() {
                         await local_first_put_promise
                         disconnect()
                         connect()
+                        return
                     }
                     options.on_res?.(remote_result)
                     // on_error will call handle_error when connection drops
@@ -702,8 +711,9 @@ function create_braid_text() {
             var params = {
                 method: 'PUT',
                 signal: options.signal,
-                retry: () => true,
             }
+            if (!options.dont_retry)
+                params.retry = () => true
             for (var x of ['headers', 'parents', 'version', 'peer', 'body', 'patches'])
                 if (options[x] != null) params[x] = options[x]
 

package/package.json

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

package/test/test.js

@@ -69,6 +69,21 @@ function createTestServer(options = {}) {
             return res.end('error')
         }
 
+        if (req.url.startsWith('/unauthorized') && req.method === 'PUT') {
+            res.statusCode = 401
+            return res.end('Unauthorized')
+        }
+
+        if (req.url.startsWith('/forbidden') && req.method === 'PUT') {
+            res.statusCode = 403
+            return res.end('Forbidden')
+        }
+
+        if (req.url.startsWith('/server_error') && req.method === 'PUT') {
+            res.statusCode = 500
+            return res.end('Internal Server Error')
+        }
+
         if (req.url.startsWith('/404')) {
             res.statusCode = 404
             return res.end('Not Found')

package/test/tests.js

@@ -46,7 +46,7 @@ runTest(
                 var ac = new AbortController()
                 braid_text.sync('/${key}', new URL('http://localhost:8889/have_error'), {
                     signal: ac.signal,
-                    on_connect: () => {
+                    on_pre_connect: () => {
                         count++
                         if (count === 2) {
                             res.end('it reconnected!')
@@ -198,7 +198,7 @@ runTest(
                 var ac = new AbortController()
                 braid_text.sync('/${key_a}', new URL('http://localhost:8889/have_error'), {
                     signal: ac.signal,
-                    on_connect: () => {
+                    on_pre_connect: () => {
                         count++
                         if (count === 2) {
                             res.end('it reconnected!')
@@ -2066,6 +2066,140 @@ runTest(
     'on_res called'
 )
 
+runTest(
+    "test braid_text.sync reconnects when inner put fails with non-200 status",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a local resource with content
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'initial'
+        })
+        if (!r.ok) return 'initial put failed: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var connect_count = 0
+                var ac = new AbortController()
+
+                braid_text.sync('/${key}', new URL('http://localhost:8889/server_error'), {
+                    signal: ac.signal,
+                    on_pre_connect: () => {
+                        connect_count++
+                        if (connect_count >= 2) {
+                            ac.abort()
+                            res.end('reconnected after put failure')
+                        }
+                    }
+                })
+
+                // Trigger a local put which will fail when synced to the error endpoint
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${key}', { body: 'trigger sync' })
+
+                // Wait for reconnect attempt
+                await new Promise(done => setTimeout(done, 2000))
+                ac.abort()
+                res.end('did not reconnect')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'reconnected after put failure'
+)
+
+runTest(
+    "test braid_text.sync on_unauthorized callback for 401",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a local resource with content
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'initial'
+        })
+        if (!r.ok) return 'initial put failed: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var unauthorized_called = false
+                var ac = new AbortController()
+
+                braid_text.sync('/${key}', new URL('http://localhost:8889/unauthorized'), {
+                    signal: ac.signal,
+                    on_unauthorized: () => {
+                        unauthorized_called = true
+                        ac.abort()
+                        res.end('on_unauthorized called')
+                    }
+                })
+
+                // Trigger a local put which will get 401 when synced
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${key}', { body: 'trigger sync' })
+
+                // Wait for callback
+                await new Promise(done => setTimeout(done, 2000))
+                ac.abort()
+                res.end('on_unauthorized not called')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'on_unauthorized called'
+)
+
+runTest(
+    "test braid_text.sync on_unauthorized callback for 403",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a local resource with content
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'initial'
+        })
+        if (!r.ok) return 'initial put failed: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var unauthorized_called = false
+                var ac = new AbortController()
+
+                braid_text.sync('/${key}', new URL('http://localhost:8889/forbidden'), {
+                    signal: ac.signal,
+                    on_unauthorized: () => {
+                        unauthorized_called = true
+                        ac.abort()
+                        res.end('on_unauthorized called')
+                    }
+                })
+
+                // Trigger a local put which will get 403 when synced
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${key}', { body: 'trigger sync' })
+
+                // Wait for callback
+                await new Promise(done => setTimeout(done, 2000))
+                ac.abort()
+                res.end('on_unauthorized not called')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'on_unauthorized called'
+)
+
 runTest(
     "test getting a binary update from a subscription",
     async () => {