@knowlearning/agents 0.4.13 → 0.5.0

package/agents/browser/embedded.js

@@ -117,13 +117,10 @@ export default function EmbeddedAgent() {
 
     if (data === undefined) return url
     else {
-      console.log('UPLOADING TO URL!!!!!!!!!!!!!!', id, url)
       const headers = { 'Content-Type': type }
       const response = await fetch(url, {method: 'PUT', headers, body: data})
       const { ok, statusText } = response
 
-      console.log(ok, statusText)
-
       if (ok) return id
       else throw new Error(statusText)
     }

package/agents/browser/firebase-auth.js

@@ -1,4 +1,4 @@
-import { initializeApp } from 'firebase/app'
+import { initializeApp } from '@firebase/app'
 import {
   getAuth,
   signOut as firebaseSignOut,
@@ -8,7 +8,7 @@ import {
   signInWithRedirect,
   signInWithEmailAndPassword,
   signInAnonymously
-} from 'firebase/auth'
+} from '@firebase/auth'
 
 initializeApp({
   "apiKey": "AIzaSyAxjYuF-2JmXxlXnGgNu2CO4Q41EAtUgrY",

package/agents/generic.js

@@ -26,7 +26,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   const responses = {}
   const watchers = {}
   const keyToSubscriptionId = {}
-  const lastInteractionUpdateForWatchedScope = {}
+  const lastInteractionResponse = {}
   const messageQueue = []
   let resolveEnvironment
   let disconnected = false
@@ -35,23 +35,24 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   const environmentPromise = new Promise(r => resolveEnvironment = r)
   let lastSentSI = -1
   let lastHeartbeat
+  const syncedPromiseResolutions = []
 
-  const subscriptions = mutate('subscriptions', false)
-  const uploads = mutate('uploads', false)
-  const downloads = mutate('downloads', false)
-  const patches = mutate('patches', false)
+  const subscriptions = {}
+  const patches = state('patches')
 
   log('INITIALIZING AGENT CONNECTION')
   initWS()
 
-  function subscription(key) {
-    return subscriptions[keyToSubscriptionId[key]]
-  }
-
   function log() {
     if (mode === 'debug') console.log(...arguments)
   }
 
+  function resolveSyncPromises() {
+    while (syncedPromiseResolutions.length) {
+      syncedPromiseResolutions.shift()()
+    }
+  }
+
   function removeWatcher(key, fn) {
     const watcherIndex = watchers[key].findIndex(x => x === fn)
     if (watcherIndex > -1) watchers[key].splice(watcherIndex, 1)
@@ -67,14 +68,15 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
   function lastMessageResponse() { //  TODO: handle error responses
-    return new Promise(r => responses[si].push(r))
+    return new Promise((resolve, reject) => responses[si].push([resolve, reject]))
   }
 
   function queueMessage(message) {
     si += 1
-    responses[si] = []
+    const promise = new Promise((resolve, reject) => responses[si] = [[resolve, reject]])
     messageQueue.push({...message, si, ts: Date.now()})
     flushMessageQueue()
+    return promise
   }
 
   function checkHeartbeat() {
@@ -144,9 +146,16 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
           if (message.si !== undefined) {
             if (responses[message.si]) {
               //  TODO: remove "acknowledged" messages fromt queue and do accounting with si
-              responses[message.si].forEach(fn => fn(message))
+              responses[message.si]
+                .forEach(([resolve, reject]) => {
+                  message.error ? reject(message) : resolve(message)
+                })
               delete responses[message.si]
               ws.send(JSON.stringify({ack: message.si})) //  acknowledgement that we have received the response for this message
+
+              if (Object.keys(responses).length === 0) {
+                resolveSyncPromises()
+              }
             }
             else {
               //  TODO: consider what to do here... probably want to throw error if in dev env
@@ -154,22 +163,22 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
             }
           }
           else {
-            const key = `${message.domain}/${message.user}/${message.scope}`
-            const sub = subscription(key)
-            if (watchers[key]) {
+            const sub = subscriptions[keyToSubscriptionId[message.scope]]
+            if (watchers[message.scope]) {
               // TODO: debug case where sub is not defined
               if (sub && sub.ii + 1 !== message.ii) {
                 //  TODO: this seems to be an error that happens with decent regularity (an answer with a given si was skipped/failed)
                 //        we should be wary of out-of-order ii being passed down (maybe need to wait for older ones???)
                 console.warn('UNEXPECTED UPDATE INTERACTION INDEX!!!!!!!!!!! last index in session', sub, ' passed index ', message.ii)
               }
-              states[key] = await states[key] || {}
+              states[message.scope] = await states[message.scope]
 
               const lastResetPatchIndex = message.patch.findLastIndex(p => p.path.length === 0)
-              if (lastResetPatchIndex > -1) states[key] = message.patch[lastResetPatchIndex].value
+              if (lastResetPatchIndex > -1) states[message.scope] = message.patch[lastResetPatchIndex].value
 
-              applyPatch(states[key], standardJSONPatch(message.patch.slice(lastResetPatchIndex + 1)))
-              watchers[key].forEach(fn => fn({ ...message, state: states[key] }))
+              if (states[message.scope].active === undefined) states[message.scope].active = {}
+              applyPatch(states[message.scope], standardJSONPatch(message.patch.slice(lastResetPatchIndex + 1)))
+              watchers[message.scope].forEach(fn => fn({ ...message, state: states[message.scope] }))
               if (sub) sub.ii = message.ii
             }
           }
@@ -192,76 +201,95 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     checkHeartbeat()
   }
 
+  function initialize(id, type, value) {
+    //  TODO: collapse into 1 patch and 1 interact call
+    interact(id, [{
+      op: 'add',
+      path: ['active_type'],
+      value: type
+    }])
+    interact(id, [{
+      op: 'add',
+      path: ['active'],
+      value
+    }])
+  }
+
   function environment() { return environmentPromise }
 
-  function state(scope, u, d) {
+  function state(scope) {
     let watchFn
-    let resolveKey
-    const key = new Promise(r => resolveKey = r)
-
-    const promise = new Promise(async resolveState => {
-      await environmentPromise // environment not set until first connection
-
-      if (!u) u = user
-      if (!d) d = domain
-
-      const k = `${d || domain}/${u || user}/${scope}`
-      resolveKey(k)
-
-      if (!keyToSubscriptionId[k]) {
+    const promise = new Promise(async (resolveState, rejectState) => {
+      if (!keyToSubscriptionId[scope]) {
         const id = uuid()
 
-        keyToSubscriptionId[k] = id
-        watchers[k] = []
-        states[k] = new Promise(async resolve => {
-
-          subscriptions[id] = {
-            session,
-            domain: d,
-            user: u,
-            scope,
-            ii: null
+        keyToSubscriptionId[scope] = id
+        watchers[scope] = []
+        states[scope] = new Promise(async (resolve, reject) => {
+
+          const subscriptionId = uuid()
+          initialize(
+            subscriptionId,
+            'application/json;type=subscription',
+            { session, scope, ii: null }
+          )
+
+          try {
+            const state = await lastMessageResponse()
+            //  TODO: replace with editing scope of type
+            interact(subscriptionId, [{
+              op: 'add',
+              path: ['active', 'ii'],
+              value: 1 // TODO: use state.ii when is coming down properly...
+            }])
+
+            resolve(state)
+
+            if (state.ii === -1) {
+              // -1 indicates the result is a computed scope, so
+              // ii does not apply (we clear out the subscription to not cache value)
+              delete states[scope]
+              delete keyToSubscriptionId[scope]
+              delete subscriptions[id]
+            }
           }
-
-          const { ii, state } = await lastMessageResponse()
-          subscriptions[id].ii = ii
-          resolve(state)
-          if (ii === -1) {
-            // -1 indicates the result is a computed scope, so
-            // ii does not apply (we clear out the subscription to not cache value)
-            delete states[k]
-            delete subscriptions[id]
+          catch (error) {
+            reject(error)
           }
         })
       }
 
-      //  TODO: make sure to get the state that represents the last interaction we sent
-      //        when this "state" method was called!!!!!!!!!!!!!!!!!!!!!!!
-      //        Right now this is simply returning whatever we have at the time we get here
-      //        when some interaction responses may not have been applied yet...
-      //        POSSIBLE: wait for most recent interaction update response for key k that we sent...
-      await lastInteractionUpdateForWatchedScope[k]
-      //  TODO: probably something like await updateMessageReceivedForLastInteractionWeSentForKey[k]
-      resolveState(structuredClone(await states[k]))
+      await lastInteractionResponse[scope]
+
+      try {
+        const state = structuredClone(await states[scope])
+
+        resolveState(new MutableProxy(state.active || {}, patch => {
+          const activePatch = structuredClone(patch)
+          activePatch.forEach(entry => entry.path.unshift('active'))
+          interact(scope, activePatch)
+        }))
+      }
+      catch (error) {
+        rejectState(error)
+      }
     })
 
     promise.watch = fn => {
-      key
-        .then( k => {
-          if (watchFn) throw new Error('Only one watcher allowed')
-          if (!watchers[k]) watchers[k] = []
-          watchers[k].push(fn)
-          watchFn = fn
-        })
+      if (watchFn) throw new Error('Only one watcher allowed')
+      if (!watchers[scope]) watchers[scope] = []
+      watchers[scope].push(fn)
+      watchFn = fn
+
       return promise
     }
 
     promise.unwatch = async () => {
-      const k = await key
-      removeWatcher(k, watchFn)
-      if (watchers[k].length === 0) {
-        delete subscriptions[keyToSubscriptionId[k]]
-        delete watchers[k]
+      removeWatcher(scope, watchFn)
+      if (watchers[scope].length === 0) {
+        delete subscriptions[keyToSubscriptionId[scope]]
+        delete keyToSubscriptionId[scope]
+        delete watchers[scope]
       }
     }
 
@@ -271,9 +299,16 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   //  TODO: if no data, set up streaming upload
   async function upload(name, type, data, id=uuid()) {
     //  TODO: include data size info...
-    uploads[id] = { url: null, sent: 0, name, type }
+    const uploadId = uuid()
+    initialize(
+      uploadId,
+      'application/json;type=upload',
+      {
+        id,
+        type
+      }
+    )
     const { url } = await lastMessageResponse()
-    uploads[id].url = url
 
     if (data === undefined) return url
     else {
@@ -287,9 +322,14 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
    async function download(id, passthrough=false) {
-    downloads[id] = { url: null, size: null, sent: 0 }
+    // TODO: initialize size info
+    const downloadId = uuid()
+    initialize(
+      downloadId,
+      'application/json;type=download',
+      { id }
+    )
     const { url } = await lastMessageResponse()
-    downloads[id].url = url
 
     if (passthrough) return url
     else {
@@ -308,30 +348,25 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
   async function interact(scope, patch) {
-    queueMessage({scope, patch})
-    const response = lastMessageResponse()
-
-    await environmentPromise
-
-    const key = `${domain}/${user}/${scope}`
+    //  TODO: ensure user is owner of scope
+    const response = queueMessage({scope, patch})
 
-    //  if we are watching this key, we want to keep track of last interaction we fired
-    if (states[key] !== undefined) {
+    //  if we are watching this scope, we want to keep track of last interaction we fired
+    if (states[scope] !== undefined) {
       let resolve
-      lastInteractionUpdateForWatchedScope[key] = new Promise(r => resolve = r)
+      lastInteractionResponse[scope] = new Promise(r => resolve = r)
 
-      const { ii } = await response
-
-      const resolveAndUnwatch = (update) => {
+      const resolveAndUnwatch = async (update) => {
+        const { ii } = await response
         if (update.ii === ii) {
           resolve(ii)
-          removeWatcher(key, resolveAndUnwatch)
+          removeWatcher(scope, resolveAndUnwatch)
         }
       }
 
-      watchers[key].push(resolveAndUnwatch)
+      watchers[scope].push(resolveAndUnwatch)
 
-      return { ii }
+      return response
     }
     else {
       const { ii } = await response
@@ -340,20 +375,36 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
   async function claim(domain) {
-    return interact('claims', [{ op: 'add', path: [domain], value: null }])
+    return interact('claims', [{ op: 'add', path: ['active', domain], value: null }])
   }
 
-  function mutate(scope, initialize=true) {
-    const mp = s => new MutableProxy(s || {}, patch => interact(scope, patch))
-    return initialize ? state(scope).then(mp) : mp({})
+  function reset(scope) {
+    return interact(scope, [{ op: 'remove', path:['active'] }])
   }
 
-  function reset(scope) {
-    return interact(scope, [{ op: 'add', path:[], value: null }])
+  function isValidMetadataMutation({ path, op, value }) {
+    return (
+      ['active_type', 'name'].includes(path[0])
+      && path.length === 1
+      && typeof value === 'string' || op === 'remove'
+    )
+  }
+
+  async function metadata(id) {
+    await state(id)
+    const md = structuredClone(await states[id])
+    delete md.active
+    return new MutableProxy(md, patch => {
+      const activePatch = structuredClone(patch)
+      activePatch.forEach(entry => {
+        if (!isValidMetadataMutation(entry)) throw new Error('You may only modify the type or name for a scope\'s metadata')
+      })
+      interact(id, activePatch)
+    })
   }
 
-  function metadata(id) {
-    return state(id, 'metadata', 'core')
+  async function synced() {
+    return new Promise(resolve => syncedPromiseResolutions.push(resolve))
   }
 
   function disconnect() {
@@ -382,9 +433,9 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     interact,
     patch,
     claim,
-    mutate,
     reset,
     metadata,
+    synced,
     disconnect,
     reconnect,
     debug

package/package.json

@@ -1,32 +1,32 @@
 {
-    "name": "@knowlearning/agents",
-    "version": "0.4.13",
-    "description": "API for embedding applications in KnowLearning systems.",
-    "main": "node.js",
-    "browser": "browser.js",
-    "type": "module",
-    "directories": {
-      "example": "examples",
-      "test": "test"
-    },
-    "scripts": {
-      "test": "echo \"Error: no test specified\" && exit 1"
-    },
-    "repository": {
-      "type": "git",
-      "url": "git+https://github.com/knowlearning/core.git"
-    },
-    "author": "KnowLearning",
-    "license": "MPL-2.0",
-    "bugs": {
-      "url": "https://github.com/knowlearning/core/issues"
-    },
-    "homepage": "https://github.com/knowlearning/core#readme",
-    "dependencies": {
-      "fast-json-patch": "^3.1.1",
-      "node-fetch": "^3.3.1",
-      "uuid": "^8.3.2",
-      "firebase": "^9.12.1"
-    }
+  "name": "@knowlearning/agents",
+  "version": "0.5.0",
+  "description": "API for embedding applications in KnowLearning systems.",
+  "main": "node.js",
+  "browser": "browser.js",
+  "type": "module",
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/knowlearning/core.git"
+  },
+  "author": "KnowLearning",
+  "license": "MPL-2.0",
+  "bugs": {
+    "url": "https://github.com/knowlearning/core/issues"
+  },
+  "homepage": "https://github.com/knowlearning/core#readme",
+  "dependencies": {
+    "@firebase/app": "^0.9.14",
+    "@firebase/auth": "^1.0.0",
+    "fast-json-patch": "^3.1.1",
+    "node-fetch": "^3.3.1",
+    "uuid": "^8.3.2"
   }
-  
+}

package/persistence/vuex.js

@@ -13,10 +13,7 @@ export default async function (storeDefinition) {
   const stateAttachedStore = await attachModuleState(savedState, storeDefinition, scopedPaths)
   const s = stateAttachedStore.state
   const originalState = s instanceof Function ? s() :  s
-  const handlePatch = patch => {
-    console.log('PATCHING STATE', patch)
-    Agent.interact(scope, patch)
-  }
+  const handlePatch = patch => Agent.interact(scope, patch)
 
   if (savedState === null) handlePatch([{ op: 'add', path: [], value: copy(originalState) }])
 

package/vue/3/component.js

@@ -12,7 +12,7 @@ export default function (module, scope) {
     const component = module.default ? { ...module.default } : { ...module } //  copy component since we will mess with mounted and data functions
 
     if (!component.ephemeral) {
-      const state = await Agent.mutate(scope)
+      const state = await Agent.state(scope)
 
       if (component.data) {
         const origDataFn = component.data