@knowlearning/agents 0.9.176 → 0.9.178

package/agents/browser/embedded.js

@@ -1,230 +1,10 @@
-import { validate as isUUID, v1 as uuid } from 'uuid'
-import PatchProxy from '@knowlearning/patch-proxy'
-import watchImplementation from '../watch.js'
+import EmbeddedAgent from '../embedded.js'
 
-export default function EmbeddedAgent() {
-  let messageIndex = 0
-  let resolveSession
-  const session = new Promise(r => resolveSession = r)
-  const responses = {}
-  const watchers = {}
-  const sentUpdates = {}
+export default () => {
+  //  default to window opener if present
+  const parent = window.opener ? window.opener : window.parent
+  const agent = EmbeddedAgent(parent)
 
-  const [ watch, removeWatcher ] = watchImplementation({ metadata, state, watchers, synced, sentUpdates, environment })
-
-  async function send(message) {
-    const requestId = message.requestId || uuid()
-
-    messageIndex += 1
-    //  default to window opener if present
-    const upstream = window.opener ? window.opener : window.parent
-    try {
-      upstream
-        .postMessage({
-          ...message,
-          session: await session,
-          requestId,
-          index: messageIndex
-        }, '*')
-      return new Promise((resolve, reject) => {
-        responses[requestId] = { resolve, reject }
-      })
-    }
-    catch (error) {
-      console.log('ERROR POSTING MESSAGE UP', message, error)
-    }
-  }
-
-  let sessionResolved = false
-  addEventListener('message', async ({ data }) => {
-    if (data.type === 'setup' && !sessionResolved) {
-      sessionResolved = true
-      resolveSession(data.session)
-    }
-    else if (!sessionResolved || data.session !== await session) return
-    else if (responses[data.requestId]) {
-      const { resolve, reject } = responses[data.requestId]
-      if (data.error) reject(data.error)
-      else resolve(data.response)
-    }
-    else if (data.ii !== undefined) {
-      const { scope, user, domain } = data
-      const { auth, domain:rootDomain } = await environment()
-      const d = !domain || domain === rootDomain ? '' : domain
-      const u = !user || auth.user === user ? '' : user
-      const key = isUUID(scope) ? scope : `${d}/${u}/${scope}`
-
-      const sendUpdate = () => {
-        sentUpdates[key] = data.ii
-        watchers[key].forEach(fn => fn(data))
-      }
-      if (watchers[key]) {
-        if (sentUpdates[key] === undefined || sentUpdates[key] + 1 === data.ii) {
-          sendUpdate()
-        } else if (data.ii === sentUpdates[key]) {
-          //console.warn('Repeated update for', key, data, sentUpdates[key])
-        } else if (data.ii < sentUpdates[key]) {
-           //console.warn('Out of order update, from past', key, JSON.stringify(data, null, 4), sentUpdates[key])
-        } else {
-          //console.warn('Out of order update, fast forward', key, JSON.stringify(data, null, 4), sentUpdates[key])
-          sendUpdate()
-        }
-      }
-    }
-  })
-
-  let variables
-
-  async function environment(user) {
-    const response = await send({ type: 'environment', user })
-    //  keep copy on initialize symantics for environment variables
-    if (!variables && !user) variables = response.variables
-    return { ...response, variables }
-  }
-
-  function create({ id=uuid(), active_type, active }) {
-    if (!active_type) active_type = 'application/json'
-    interact(id, [
-      { op: 'add', path: ['active_type'], value: active_type },
-      { op: 'add', path: ['active'], value: active }
-    ])
-    return id
-  }
-
-  async function patch(root, scopes) {
-    //  TODO: consider watch function added to return to receive progress
-    return send({ type: 'patch', root, scopes })
-  }
-
-  async function state(scope, user, domain) {
-    if (scope === undefined) {
-      const { context } = await environment()
-      scope = JSON.stringify(context)
-    }
-    const startState = await send({ type: 'state', scope, user, domain })
-    return new PatchProxy(startState, patch => {
-      //  TODO: reject updates if user is not owner
-      const activePatch = structuredClone(patch)
-      activePatch.forEach(entry => entry.path.unshift('active'))
-      interact(scope, activePatch)
-    })
-  }
-
-  function reset(scope) {
-    return interact(scope, [{ op: 'add', path:['active'], value: null }])
-  }
-
-  function interact(scope, patch, _, context) {
-    return send({ type: 'interact', scope, patch, context })
-  }
-
-  async function upload(info) {
-    let { name, type, data, id=uuid() } = info || {}
-
-    const url = await send({ type: 'upload', info: { name, type, id } })
-
-    if (data === undefined) return url
-    else {
-      const headers = { 'Content-Type': type }
-      const response = await fetch(url, {method: 'PUT', headers, body: data})
-      const { ok, statusText } = response
-
-      if (ok) return id
-      else throw new Error(statusText)
-    }
-  }
-
-  function download(id) {
-    let mode = 'fetch'
-    const promise = new Promise(async (resolve, reject) => {
-      const url = await send({ type: 'download', id })
-
-      await new Promise(r => setTimeout(r))
-      if (mode === 'url') resolve(url)
-      else if (mode === 'fetch') {
-        const response = await fetch(url)
-        const { ok, statusText } = response
-
-        if (ok) resolve(response)
-        else reject(statusText)
-      }
-      else if (mode === 'direct') {
-        //  TODO: use browser progress UX instead of downloading all into memory first
-        const res = await download(id)
-        const { name } = await metadata(id)
-        const type = res.headers.get('Content-Type')
-        const blob = new Blob([ await res.blob() ], { type })
-        const url = window.URL.createObjectURL(blob)
-        const a = document.createElement('a')
-        a.style.display = 'none'
-        a.href = url
-        a.download = name
-        document.body.appendChild(a)
-        a.click()
-        window.URL.revokeObjectURL(url)
-        resolve()
-      }
-    })
-    promise.direct = () => {
-      mode = 'direct'
-      return promise
-    }
-    promise.url = () => {
-      mode = 'url'
-      return promise
-    }
-    return promise
-  }
-
-  function isValidMetadataMutation({ path, op, value }) {
-    return (
-      ['active_type', 'name'].includes(path[0])
-      && path.length === 1
-      && typeof value === 'string' || op === 'remove'
-    )
-  }
-
-  async function metadata(scope, user, domain) {
-    const md = await send({ type: 'metadata', scope, user, domain })
-    return new PatchProxy(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(scope, activePatch)
-    })
-  }
-
-  function login(provider, username, password) {
-    return send({ type: 'login', provider, username, password })
-  }
-
-  function query(query, params, domain, context=[]) { return send({ type: 'query', query, params, domain, context }) }
-  function logout() { return send({ type: 'logout' }) }
-  function disconnect() { return send({ type: 'disconnect' }) }
-  function reconnect() { return send({ type: 'reconnect' }) }
-  function synced() { return send({ type: 'synced' }) }
-  function close(info) { return send({ type: 'close', info }) }
-
-  return {
-    embedded: true,
-    uuid,
-    environment,
-    login,
-    logout,
-    create,
-    state,
-    watch,
-    upload,
-    download,
-    interact,
-    patch,
-    reset,
-    metadata,
-    disconnect,
-    reconnect,
-    synced,
-    close,
-    query
-  }
+  return agent
 }
+

package/agents/embedded.js

@@ -0,0 +1,228 @@
+import { validate as isUUID, v1 as uuid } from 'uuid'
+import PatchProxy from '@knowlearning/patch-proxy'
+import watchImplementation from './watch.js'
+
+export default function EmbeddedAgent(parent) {
+  let messageIndex = 0
+  let resolveSession
+  const session = new Promise(r => resolveSession = r)
+  const responses = {}
+  const watchers = {}
+  const sentUpdates = {}
+
+  const [ watch, removeWatcher ] = watchImplementation({ metadata, state, watchers, synced, sentUpdates, environment })
+
+  async function send(message) {
+    const requestId = message.requestId || uuid()
+
+    messageIndex += 1
+    try {
+      parent
+        .postMessage({
+          ...message,
+          session: await session,
+          requestId,
+          index: messageIndex
+        }, '*')
+      return new Promise((resolve, reject) => {
+        responses[requestId] = { resolve, reject }
+      })
+    }
+    catch (error) {
+      console.log('ERROR POSTING MESSAGE UP', message, error)
+    }
+  }
+
+  let sessionResolved = false
+  addEventListener('message', async ({ data }) => {
+    if (data.type === 'setup' && !sessionResolved) {
+      sessionResolved = true
+      resolveSession(data.session)
+    }
+    else if (!sessionResolved || data.session !== await session) return
+    else if (responses[data.requestId]) {
+      const { resolve, reject } = responses[data.requestId]
+      if (data.error) reject(data.error)
+      else resolve(data.response)
+    }
+    else if (data.ii !== undefined) {
+      const { scope, user, domain } = data
+      const { auth, domain:rootDomain } = await environment()
+      const d = !domain || domain === rootDomain ? '' : domain
+      const u = !user || auth.user === user ? '' : user
+      const key = isUUID(scope) ? scope : `${d}/${u}/${scope}`
+
+      const sendUpdate = () => {
+        sentUpdates[key] = data.ii
+        watchers[key].forEach(fn => fn(data))
+      }
+      if (watchers[key]) {
+        if (sentUpdates[key] === undefined || sentUpdates[key] + 1 === data.ii) {
+          sendUpdate()
+        } else if (data.ii === sentUpdates[key]) {
+          //console.warn('Repeated update for', key, data, sentUpdates[key])
+        } else if (data.ii < sentUpdates[key]) {
+           //console.warn('Out of order update, from past', key, JSON.stringify(data, null, 4), sentUpdates[key])
+        } else {
+          //console.warn('Out of order update, fast forward', key, JSON.stringify(data, null, 4), sentUpdates[key])
+          sendUpdate()
+        }
+      }
+    }
+  })
+
+  let variables
+
+  async function environment(user) {
+    const response = await send({ type: 'environment', user })
+    //  keep copy on initialize symantics for environment variables
+    if (!variables && !user) variables = response.variables
+    return { ...response, variables }
+  }
+
+  function create({ id=uuid(), active_type, active }) {
+    if (!active_type) active_type = 'application/json'
+    interact(id, [
+      { op: 'add', path: ['active_type'], value: active_type },
+      { op: 'add', path: ['active'], value: active }
+    ])
+    return id
+  }
+
+  async function patch(root, scopes) {
+    //  TODO: consider watch function added to return to receive progress
+    return send({ type: 'patch', root, scopes })
+  }
+
+  async function state(scope, user, domain) {
+    if (scope === undefined) {
+      const { context } = await environment()
+      scope = JSON.stringify(context)
+    }
+    const startState = await send({ type: 'state', scope, user, domain })
+    return new PatchProxy(startState, patch => {
+      //  TODO: reject updates if user is not owner
+      const activePatch = structuredClone(patch)
+      activePatch.forEach(entry => entry.path.unshift('active'))
+      interact(scope, activePatch)
+    })
+  }
+
+  function reset(scope) {
+    return interact(scope, [{ op: 'add', path:['active'], value: null }])
+  }
+
+  function interact(scope, patch, _, context) {
+    return send({ type: 'interact', scope, patch, context })
+  }
+
+  async function upload(info) {
+    let { name, type, data, id=uuid() } = info || {}
+
+    const url = await send({ type: 'upload', info: { name, type, id } })
+
+    if (data === undefined) return url
+    else {
+      const headers = { 'Content-Type': type }
+      const response = await fetch(url, {method: 'PUT', headers, body: data})
+      const { ok, statusText } = response
+
+      if (ok) return id
+      else throw new Error(statusText)
+    }
+  }
+
+  function download(id) {
+    let mode = 'fetch'
+    const promise = new Promise(async (resolve, reject) => {
+      const url = await send({ type: 'download', id })
+
+      await new Promise(r => setTimeout(r))
+      if (mode === 'url') resolve(url)
+      else if (mode === 'fetch') {
+        const response = await fetch(url)
+        const { ok, statusText } = response
+
+        if (ok) resolve(response)
+        else reject(statusText)
+      }
+      else if (mode === 'direct') {
+        //  TODO: use browser progress UX instead of downloading all into memory first
+        const res = await download(id)
+        const { name } = await metadata(id)
+        const type = res.headers.get('Content-Type')
+        const blob = new Blob([ await res.blob() ], { type })
+        const url = window.URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.style.display = 'none'
+        a.href = url
+        a.download = name
+        document.body.appendChild(a)
+        a.click()
+        window.URL.revokeObjectURL(url)
+        resolve()
+      }
+    })
+    promise.direct = () => {
+      mode = 'direct'
+      return promise
+    }
+    promise.url = () => {
+      mode = 'url'
+      return promise
+    }
+    return promise
+  }
+
+  function isValidMetadataMutation({ path, op, value }) {
+    return (
+      ['active_type', 'name'].includes(path[0])
+      && path.length === 1
+      && typeof value === 'string' || op === 'remove'
+    )
+  }
+
+  async function metadata(scope, user, domain) {
+    const md = await send({ type: 'metadata', scope, user, domain })
+    return new PatchProxy(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(scope, activePatch)
+    })
+  }
+
+  function login(provider, username, password) {
+    return send({ type: 'login', provider, username, password })
+  }
+
+  function query(query, params, domain, context=[]) { return send({ type: 'query', query, params, domain, context }) }
+  function logout() { return send({ type: 'logout' }) }
+  function disconnect() { return send({ type: 'disconnect' }) }
+  function reconnect() { return send({ type: 'reconnect' }) }
+  function synced() { return send({ type: 'synced' }) }
+  function close(info) { return send({ type: 'close', info }) }
+
+  return {
+    embedded: true,
+    uuid,
+    environment,
+    login,
+    logout,
+    create,
+    state,
+    watch,
+    upload,
+    download,
+    interact,
+    patch,
+    reset,
+    metadata,
+    disconnect,
+    reconnect,
+    synced,
+    close,
+    query
+  }
+}

package/agents/generic/message-queue.js

@@ -127,7 +127,7 @@ export default function messageQueue({ token, sid, domain, Connection, watchers,
 
         if (!authed) {
           //  TODO: credential refresh flow instead of forcing login
-          if (message.error) return login()
+          if (message.error) alert('Authentication Error. Please try again.')
 
           authed = true
           if (!user) { // this is the first authed websocket connection

package/package.json

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