@knowlearning/agents 0.9.29 → 0.9.30

package/agents/browser/embedded.js

@@ -1,4 +1,5 @@
 import { validate as isUUID, v1 as uuid } from 'uuid'
+import watchImplementation from '../watch.js'
 import MutableProxy from '../../persistence/json.js'
 
 export default function EmbeddedAgent() {
@@ -9,11 +10,7 @@ export default function EmbeddedAgent() {
   const watchers = {}
   const sentUpdates = {}
 
-  function removeWatcher(key, fn) {
-    const watcherIndex = watchers[key].findIndex(x => x === fn)
-    if (watcherIndex > -1) watchers[key].splice(watcherIndex, 1)
-    else console.warn('TRIED TO REMOVE WATCHER THAT DOES NOT EXIST')
-  }
+  const [ watch, removeWatcher ] = watchImplementation({ metadata, state, watchers, synced, sentUpdates, environment })
 
   async function send(message) {
     const requestId = message.requestId || uuid()
@@ -57,12 +54,15 @@ export default function EmbeddedAgent() {
       const u = !user || auth.user === user ? '' : user
       const key = isUUID(scope) ? scope : `${d}/${u}/${scope}`
       if (watchers[key]) {
-        if (sentUpdates[key] + 1 === data.ii) {
+        if (sentUpdates[key] === undefined || sentUpdates[key] + 1 === data.ii) {
           sentUpdates[key] = data.ii
           watchers[key].forEach(fn => fn(data))
         }
-        else if (data.ii !== sentUpdates[key]) {
-          console.warn('Out of order or repeated update for', key, data.ii, sentUpdates[key])
+        else if (data.ii === sentUpdates[key]) {
+          console.warn('Repeated update for', key, data, sentUpdates[key])
+        }
+        else {
+          console.warn('Out of order update for', key, data, sentUpdates[key])
         }
       }
     }
@@ -96,37 +96,6 @@ export default function EmbeddedAgent() {
     await tag(tag_type, target)
   }
 
-  function watch(scope, fn, user, domain) {
-    let watchingPath = false
-    if (scope && scope.length === 1) {
-      watchingPath = true
-      scope = scope[0]
-    }
-    //  TODO: actually allow watching at paths in embedded
-
-    tagIfNotYetTaggedInSession('subscribed', scope)
-
-    const wrappedFn = update => fn(watchingPath ? update.state : update)
-
-    const key = (
-      environment()
-        .then(async ({ auth, domain:rootDomain }) => {
-          const d = !domain || domain === rootDomain ? '' : domain
-          const u = !user || auth.user === user ? '' : user
-          const key = isUUID(scope) ? scope : `${d}/${u}/${scope}`
-
-          const state = await send({ type: 'state', scope, user, domain })
-          const metadata = await send({ type: 'metadata', scope, user, domain })
-          wrappedFn({ state, patch: null, ii: metadata.ii })
-          sentUpdates[key] = metadata.ii
-          if (!watchers[key]) watchers[key] = []
-          watchers[key].push(wrappedFn)
-          return key
-        })
-    )
-    return async () => removeWatcher(await key, wrappedFn)
-  }
-
   async function patch(root, scopes) {
     //  TODO: consider watch function added to return to receive progress
     return send({ type: 'patch', root, scopes })
@@ -221,8 +190,8 @@ export default function EmbeddedAgent() {
     )
   }
 
-  async function metadata(scope) {
-    const md = await send({ type: 'metadata', scope })
+  async function metadata(scope, user, domain) {
+    const md = await send({ type: 'metadata', scope, user, domain })
     return new MutableProxy(md, patch => {
       const activePatch = structuredClone(patch)
       activePatch.forEach(entry => {

package/agents/browser/initialize.js

@@ -72,8 +72,8 @@ function embed(environment, iframe) {
       sendDown({}) // TODO: might want to send down the interaction index
     }
     else if (type === 'metadata') {
-      const { scope, user } = message
-      sendDown(await Agent.metadata(scope, user))
+      const { scope, user, domain } = message
+      sendDown(await Agent.metadata(scope, user, domain))
     }
     else if (type === 'tag') {
       const { tag_type, target, context } = message

package/agents/generic/index.js

@@ -2,7 +2,7 @@ import { validate as isUUID } from 'uuid'
 import MutableProxy from '../../persistence/json.js'
 import messageQueue from './message-queue.js'
 import stateImplementation from './state.js'
-import watchImplementation from './watch.js'
+import watchImplementation from '../watch.js'
 import downloadImplementation from '../download.js'
 
 // TODO: consider using something better than name as mechanism
@@ -157,7 +157,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     )
   }
 
-  async function metadata(id=DEFAULT_SCOPE_NAME, user) {
+  async function metadata(id=DEFAULT_SCOPE_NAME, user, domain) {
     const md = structuredClone(await state(id, user).metadata)
     delete md.active
     return new MutableProxy(md, patch => {

package/agents/{generic/watch.js → watch.js}

@@ -1,15 +1,23 @@
 import { validate as isUUID } from 'uuid'
 
-export default function({ metadata, state, watchers, synced }) {
+const DEFAULT_SCOPE_NAME = '[]'
+
+export default function({ metadata, environment, state, watchers, synced, sentUpdates }) {
 
   function watch(scope=DEFAULT_SCOPE_NAME, fn, user, domain) {
     if (Array.isArray(scope)) return watchResolution(scope, fn, user, domain)
 
     const statePromise = state(scope, user, domain)
-    const qualifiedScope = isUUID(scope) ? scope : `${domain || ''}/${user || ''}/${scope}`
 
+    let qualifiedScope
+    let removed = false
     metadata(scope, user, domain)
       .then(async ({ ii }) => {
+        if (removed) return
+
+        const { auth: { user: u }, domain: d } = await environment()
+        qualifiedScope = isUUID(scope) ? scope : `${!domain || domain === d ? '' : domain}/${!user || user === u ? '' : user}/${scope}`
+
         fn({
           scope,
           user,
@@ -18,11 +26,19 @@ export default function({ metadata, state, watchers, synced }) {
           patch: null,
           ii
         })
+
+        if (sentUpdates) sentUpdates[qualifiedScope] = ii
+
+        if (removed) return
+
         if (!watchers[qualifiedScope]) watchers[qualifiedScope] = []
         watchers[qualifiedScope].push(fn)
       })
 
-    return () => removeWatcher(qualifiedScope, fn)
+    return () => {
+      removed = true
+      return removeWatcher(qualifiedScope, fn)
+    }
   }
 
   function watchResolution(path, callback, user, domain) {

package/package.json

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