@knowlearning/agents 0.9.69 → 0.9.70

package/agents/browser/root.js

@@ -11,11 +11,23 @@ function isLocal() { return localStorage.getItem('api') === 'local' }
 export default options => {
   const { host, protocol } = window.location
 
+  const Connection = function () {
+    const ws = new WebSocket(`${protocol === 'https:' ? 'wss' : 'ws'}://${isLocal() ? DEVELOPMENT_HOST : REMOTE_HOST}`)
+
+    this.send = message => ws.send(message)
+    this.close = () => ws.close()
+
+    ws.onopen = () => this.onopen && this.onopen()
+    ws.onmessage = ({ data }) => this.onmessage && this.onmessage(data)
+    ws.onerror = error => this.onerror && this.onerror(error)
+    ws.onclose = error => this.onclose && this.onclose(error)
+
+    return this
+  }
+
   const agent = GenericAgent({
-    host: isLocal() ? DEVELOPMENT_HOST : REMOTE_HOST,
-    protocol: protocol === 'https:' ? 'wss' : 'ws',
     token: options.getToken || getToken,
-    WebSocket,
+    Connection,
     uuid,
     fetch,
     applyPatch,

package/agents/generic/index.js

@@ -13,7 +13,7 @@ const POSTGRES_QUERY_TYPE = 'application/json;type=postgres-query'
 const TAG_TYPE = 'application/json;type=tag'
 const DOMAIN_CLAIM_TYPE = 'application/json;type=domain-claim'
 
-export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fetch, applyPatch, login, logout, reboot }) {
+export default function Agent({ Connection, token, uuid, fetch, applyPatch, login, logout, reboot }) {
   const states = {}
   const watchers = {}
   const keyToSubscriptionId = {}
@@ -29,7 +29,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     reconnect,
     synced,
     environment
-  ] = messageQueue({ token, protocol, host, WebSocket, watchers, states, applyPatch, log, login, interact })
+  ] = messageQueue({ token, Connection, watchers, states, applyPatch, log, login, interact, reboot })
 
   // initialize session
   environment()

package/agents/generic/message-queue.js

@@ -14,8 +14,8 @@ function sanitizeJSONPatchPathSegment(s) {
   else return s
 }
 
-export default function messageQueue({ token, protocol, host, WebSocket, watchers, states, applyPatch, log, login }) {
-  let ws
+export default function messageQueue({ token, Connection, watchers, states, applyPatch, log, login, reboot }) {
+  let connection
   let user
   let authed = false
   let session
@@ -66,13 +66,19 @@ export default function messageQueue({ token, protocol, host, WebSocket, watcher
     await new Promise(r=>r())
     lastSynchronousScopePatched = null
 
-    while (authed && ws.readyState === WebSocket.OPEN && lastSentSI+1 < messageQueue.length) {
+    while (authed && lastSentSI+1 < messageQueue.length) {
       lastSynchronousScopePatched = null
-      lastSentSI += 1
-      ws.send(JSON.stringify(messageQueue[lastSentSI]))
-
-      //  async so we don't try and push more to a closed connection
-      await new Promise(r=>r())
+      try {
+        connection.send(JSON.stringify(messageQueue[lastSentSI + 1]))
+        lastSentSI += 1
+        //  async so we don't try and push more to a closed connection
+        await new Promise(r=>r())
+      }
+      catch (error) {
+        console.warn('ERROR SENDING OVER CONNECTION', error)
+        restartConnection()
+        break
+      }
     }
   }
 
@@ -100,25 +106,25 @@ export default function messageQueue({ token, protocol, host, WebSocket, watcher
     authed = false
     if (!disconnected) {
       await new Promise(r => setTimeout(r, Math.min(1000, failedConnections * 100)))
-      ws.onmessage = () => {} // needs to be a no-op since a closing ws can still get messages
+      connection.onmessage = () => {} // needs to be a no-op since a closing connection can still get messages
       restarting = true
       failedConnections += 1
-      initWS() // TODO: don't do this if we are purposefully unloading...
+      initConnection() // TODO: don't do this if we are purposefully unloading...
       restarting = false
     }
   }
 
-  function initWS() {
-    ws = new WebSocket(`${protocol}://${host}`)
+  function initConnection() {
+    connection = new Connection()
 
-    ws.onopen = async () => {
+    connection.onopen = async () => {
       if (!sessionMetrics.connected) sessionMetrics.connected = Date.now()
-      log('AUTHORIZING NEWLY OPENED WS FOR SESSION:', session)
+      log('AUTHORIZING NEWLY OPENED CONNECTION FOR SESSION:', session)
       failedConnections = 0
-      ws.send(JSON.stringify({ token: await token(), session }))
+      connection.send(JSON.stringify({ token: await token(), session }))
     }
 
-    ws.onmessage = async ({ data }) => {
+    connection.onmessage = async data => {
       checkHeartbeat()
       if (data.length === 0) return // heartbeat
 
@@ -161,7 +167,7 @@ export default function messageQueue({ token, protocol, host, WebSocket, watcher
                 .forEach(([res, rej]) => message.error ? rej(message) : res(message))
 
               delete responses[message.si]
-              ws.send(JSON.stringify({ack: message.si})) //  acknowledgement that we have received the response for this message
+              connection.send(JSON.stringify({ack: message.si})) //  acknowledgement that we have received the response for this message
               resolveSyncPromises()
             }
             else {
@@ -200,16 +206,16 @@ export default function messageQueue({ token, protocol, host, WebSocket, watcher
         }
       }
       catch (error) {
-        console.error('ERROR HANDLING WS MESSAGE', error)
+        console.error('ERROR HANDLING CONNECTION MESSAGE', error)
       }
     }
 
-    ws.onerror = async error => {
-      log('WS CONNECTION ERROR', error.message)
+    connection.onerror = async error => {
+      log('CONNECTION ERROR', error.message)
     }
 
-    ws.onclose = async error => {
-      log('WS CLOSURE', error.message)
+    connection.onclose = async error => {
+      log('CONNECTION CLOSURE', error.message)
       restartConnection()
     }
 
@@ -227,7 +233,7 @@ export default function messageQueue({ token, protocol, host, WebSocket, watcher
   function disconnect() {
     log('DISCONNECTED AGENT!!!!!!!!!!!!!!!')
     disconnected = true
-    ws.close()
+    connection.close()
   }
 
   function reconnect() {
@@ -236,7 +242,7 @@ export default function messageQueue({ token, protocol, host, WebSocket, watcher
     restartConnection()
   }
 
-  initWS()
+  initConnection()
 
   return [queueMessage, lastMessageResponse, disconnect, reconnect, synced, environment]
 }

package/deno.js

@@ -4,10 +4,23 @@ import Agent from './agents/generic/index.js'
 const SERVE_HOST = Deno.env.get("SERVE_HOST")
 const SERVICE_ACCOUNT_TOKEN = Deno.env.get("SERVICE_ACCOUNT_TOKEN")
 
+const postMessage = message => self.postMessage(message)
+
+function Connection() {
+  this.send = postMessage
+
+  (async function () {
+    await new Promise(r => setTimeout(r))
+    this.onopen && this.onopen()
+  })()
+
+  //  TODO: consider what onclose and onerror mean in this case
+  return this
+}
+
 export default new Agent({
-  host: SERVE_HOST,
+  Connection,
   token: () => Deno.readTextFile(SERVICE_ACCOUNT_TOKEN),
-  WebSocket,
   uuid: () => crypto.randomUUID(),
   fetch,
   applyPatch: fastJSONPatch.applyPatch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowlearning/agents",
-  "version": "0.9.69",
+  "version": "0.9.70",
   "description": "API for embedding applications in KnowLearning systems.",
   "main": "node.js",
   "browser": "browser.js",