@knowlearning/agents 0.9.7 → 0.9.9

package/agents/generic.js

@@ -2,6 +2,7 @@ import MutableProxy from '../persistence/json.js'
 import download from './download.js'
 
 const HEARTBEAT_TIMEOUT = 10000
+const SESSION_TYPE = 'application/json;type=session'
 const UPLOAD_TYPE = 'application/json;type=upload'
 const SUBSCRIPTION_TYPE = 'application/json;type=subscription'
 const POSTGRES_QUERY_TYPE = 'application/json;type=postgres-query'
@@ -23,6 +24,12 @@ function sanitizeJSONPatchPathSegment(s) {
   else return s
 }
 
+const sessionMetrics = {
+  loaded: Date.now(),
+  connected: null,
+  authenticated: null
+}
+
 export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fetch, applyPatch, login, logout, reboot }) {
   let ws
   let user
@@ -119,6 +126,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     ws = new WebSocket(`${protocol}://${host}`)
 
     ws.onopen = async () => {
+      if (!sessionMetrics.connected) sessionMetrics.connected = Date.now()
       log('AUTHORIZING NEWLY OPENED WS FOR SESSION:', session)
       failedConnections = 0
       ws.send(JSON.stringify({ token: await token(), session }))
@@ -141,10 +149,18 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
 
           authed = true
           if (!user) { // this is the first authed websocket connection
+            sessionMetrics.authenticated = Date.now()
             user = message.auth.user
             session = message.session
             domain = message.domain
             server = message.server
+
+            // save session metrics
+            interact(session, [
+              {op: 'add', path: ['active', 'loaded'], value: sessionMetrics.loaded },
+              {op: 'add', path: ['active', 'connected'], value: sessionMetrics.connected },
+              {op: 'add', path: ['active', 'authenticated'], value: sessionMetrics.authenticated },
+            ])
             resolveEnvironment(message)
           }
           else if (server !== message.server) {
@@ -248,30 +264,19 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
           create({
             id,
             active_type: SUBSCRIPTION_TYPE,
-            active: { session, scope, ii: null }
+            active: { session, scope, ii: null, initialized: Date.now() },
           })
 
           try {
             const state = await lastMessageResponse()
-            //  TODO: replace with editing scope of type
-            interact(id, [{
-              op: 'add',
-              path: ['active', 'ii'],
-              value: 1 // TODO: use state.ii when is coming down properly...
-            }])
+            interact(id, [
+              { op: 'add', path: ['active', 'ii'], value: 1 }, // TODO: use state.ii when is coming down properly...
+              { op: 'add', path: ['active', 'synced'], value: Date.now() }
+            ])
 
             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]
-            }
-          }
-          catch (error) {
-            reject(error)
           }
+          catch (error) { reject(error) }
         })
       }
 
@@ -424,11 +429,14 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
   async function query(query, params, domain) {
+    const id = uuid()
     create({
+      id,
       active_type: POSTGRES_QUERY_TYPE,
-      active: { query, params, domain }
+      active: { query, params, domain, requested: Date.now() },
     })
     const { rows } = await lastMessageResponse()
+    interact(id, [{ op: 'add', path: ['active', 'responded'], value: Date.now() }])
     return rows
   }
 

package/package.json

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

package/vue/3/components/scope.vue

@@ -0,0 +1,51 @@
+<template>
+  <pre v-if="state">{{value}}</pre>
+  <span v-else>loading...</span>
+</template>
+
+<script>
+
+  export default {
+  	props: {
+  	  id: String,
+      path: {
+        type: Array,
+        default: []
+      }
+  	},
+  	data() {
+  	  return {
+  	  	state: null
+  	  }
+  	},
+    watch: {
+      id() {
+        this.stopWatching()
+        this.startWatching()
+      }
+    },
+    mounted() {
+      this.startWatching()
+  	},
+    unmounted() {
+      this.stopWatching()
+    },
+    computed: {
+      value() {
+        if (this.path.length === 0) return this.state
+
+        return (
+          this
+            .path
+            .reduce((acc, field) => acc?.[field], this.state)
+        )
+      }
+    },
+    methods: {
+      startWatching() {
+        this.stopWatching = Agent.watch(this.id, ({ state }) => this.state = state)
+      }
+    }
+  }
+
+</script>

package/vue/3/{component.js → persist/component.js}

@@ -1,5 +1,5 @@
 import { watchEffect, defineAsyncComponent } from 'vue'
-import { browserAgent } from '../../browser.js'
+import { browserAgent } from '../../../browser.js'
 
 const Agent = browserAgent()
 

package/{persistence → vue/3/persist}/vuex.js

@@ -1,4 +1,4 @@
-import MutableProxy from './json.js'
+import MutableProxy from '../../../persistence/json.js'
 
 //  TODO: consider path serialization approach. Also consider just using a mutable proxy from agent.state...
 
@@ -9,12 +9,12 @@ async function scopeIsUninitialized(scope) {
   return Object.keys(await Agent.state(scope)).length === 0
 }
 
-export default async function (storeDefinition, scope=window.location.host) {
+export default async function (storeDefinition, scope) {
   let state = copy(await Agent.state(scope))
   const scopedPaths = getScopedPaths(storeDefinition)
   const stateAttachedStore = await attachModuleState(state, storeDefinition, scopedPaths)
   const s = stateAttachedStore.state
-  const originalState = s instanceof Function ? s() :  s
+  const originalState = s instanceof Function ? s() : s
 
   const handlePatch = patch => {
     patch.forEach(({ path }) => path.unshift('active'))
@@ -72,11 +72,12 @@ async function attachModuleState(state, module, scopedPaths, path='') {
     const ephemeralPaths = descendantPaths(path, scopedPaths)
     state = MutableProxy(copy(initState), handlePatch, ephemeralPaths)
     if (await scopeIsUninitialized(scope)) {
-      Object.assign(state, module.state())
+      Object.assign(state, module.state instanceof Function ? module.state() : module.state)
     }
     return { ...module, state: () => state }
   }
-  else return state ? { ...module, state: () => state } : module
+  //  TODO: better check for initialized state
+  else return Object.keys(state).length ? { ...module, state: () => state } : module
 }
 
 function getScopedPaths(module, path="", paths={}) {

package/vue.js

@@ -1,4 +1,5 @@
-export { default as vuePersistentStore } from './persistence/vuex.js'
-export { default as vueEmbedComponent } from './vue/3/content.vue'
-export { default as vueNameComponent } from './vue/3/name.vue'
-export { default as vuePersistentComponent } from './vue/3/component.js'
+export { default as vuePersistentStore } from './vue/3/persist/vuex.js'
+export { default as vuePersistentComponent } from './vue/3/persist/component.js'
+export { default as vueEmbedComponent } from './vue/3/components/content.vue'
+export { default as vueNameComponent } from './vue/3/components/name.vue'
+export { default as vueScopeComponent } from './vue/3/components/scope.vue'