@live-change/access-control-service 0.9.228 → 0.9.230

package/accessControl.js

@@ -1,11 +1,12 @@
 import definition from './definition.js'
 import App from '@live-change/framework'
-import { ObservableValue, ObservableList, ObservableProxy, ObservablePromiseProxy } from '@live-change/dao'
 const app = App.app()
 
 import accessModule from './access.js'
 const access = accessModule(definition)
 
+import { wrapViewObservable } from './wrapViewObservable.js'
+
 definition.processor({
   priority: -1,
   process(service, app) {
@@ -25,7 +26,7 @@ definition.processor({
       
         const { objectType, object } = properties
         const objects = [].concat(
-          config.objects ? config.objects(properties) :
+          config.objects ? await config.objects(properties) :
             ((objectType && object) ? [{ objectType, object }] : [])
         )
 
@@ -57,7 +58,7 @@ definition.processor({
         const { client } = context
         const { objectType, object } = properties
         const objects = [].concat(
-          config.objects ? config.objects(properties) :
+          config.objects ? await config.objects(properties) :
             ((objectType && object) ? [{ objectType, object }] : [])
         )
         if(objects.length === 0) {
@@ -72,57 +73,14 @@ definition.processor({
         if(!accessible) throw app.logicError("notAuthorized")
         return oldGet.apply(view, args)
       }
-      view.observable = (...args) => {
-        const [ properties, context ] = args
-        const { client } = context
-        const { objectType, object } = properties
-        const objects = [].concat(
-          config.objects ? config.objects(properties) :
-            ((objectType && object) ? [{ objectType, object }] : [])
-        )
-        if(objects.length === 0) {
-          console.warn('no objects for ' + service.name + ' view ' + viewName + ' access control to work - only global roles will be checked')
-        }
-
-        const rolesPath = access.accessPath(client, objects)
-
-        const errorObservable = new ObservableValue()
-        errorObservable.handleError('notAuthorized')
-
-        const observableProxy = new ObservableProxy(null)
-
-        let valueObservable
-
-        let accessible
-        const rolesObservable = app.dao.observable(rolesPath)
-        const rolesObserver = (signal, value) => {
-          const accessObject = rolesObservable.getValue()
-          const newAccessible = accessObject ? access.testRoles(config.roles, accessObject.roles) : false
-          if(newAccessible !== accessible) {
-            if(newAccessible === true /*&& !valueObservable*/) {
-              valueObservable = oldObservable.apply(view, args)
-              if(valueObservable.then) {
-                valueObservable = new ObservablePromiseProxy(valueObservable)
-              }
-            }
-            observableProxy.setTarget(newAccessible ? valueObservable : errorObservable)
-            accessible = newAccessible
-          }
-        }
-        rolesObservable.observe(rolesObserver)
-
-        const oldDispose = observableProxy.dispose
-        const oldRespawn = observableProxy.respawn
-        observableProxy.dispose = () => {
-          rolesObservable.unobserve(rolesObserver)
-          oldDispose.apply(observableProxy)
-        }
-        observableProxy.respawn = () => {
-          rolesObservable.observe(rolesObserver)
-          oldRespawn.apply(observableProxy)
-        }
-        return observableProxy
-      }
+      view.observable = wrapViewObservable({
+        access,
+        app,
+        oldObservable,
+        view,
+        config,
+        viewName: service.name + ' view ' + viewName
+      })
     }
 
   }

package/accessControl.test.mjs

@@ -0,0 +1,166 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { ObservableValue } from '@live-change/dao'
+import { wrapViewObservable } from './wrapViewObservable.js'
+
+function testRoles(requiredRoles, clientRoles) {
+  if (!requiredRoles || requiredRoles.length === 0) return true
+  for (const requiredRolesOption of requiredRoles) {
+    const option = Array.isArray(requiredRolesOption) ? requiredRolesOption : [requiredRolesOption]
+    if (option.every(role => clientRoles.includes(role))) return true
+  }
+  return false
+}
+
+function createRolesObservable() {
+  const observers = []
+  return {
+    value: undefined,
+    observeCount: 0,
+    unobserveCount: 0,
+    observers,
+    observe(fn) {
+      this.observeCount++
+      observers.push(fn)
+      if (this.value !== undefined) {
+        if (typeof fn === 'function') fn('set', this.value)
+        else if (fn.set) fn.set(this.value)
+      }
+    },
+    unobserve(fn) {
+      this.unobserveCount++
+      const i = observers.indexOf(fn)
+      if (i >= 0) observers.splice(i, 1)
+    },
+    getValue() {
+      return this.value
+    },
+    set(value) {
+      this.value = value
+      for (const fn of [...observers]) {
+        if (typeof fn === 'function') fn('set', value)
+        else if (fn.set) fn.set(value)
+      }
+    }
+  }
+}
+
+function createValueObservable(initial) {
+  const inner = new ObservableValue(initial)
+  inner.disposeCount = 0
+  const originalDispose = inner.dispose.bind(inner)
+  inner.dispose = () => {
+    inner.disposeCount++
+    originalDispose()
+  }
+  return inner
+}
+
+function wrapWith(rolesObservable, oldObservable) {
+  return wrapViewObservable({
+    access: {
+      accessPath: () => ['roles', 'path'],
+      testRoles
+    },
+    app: {
+      dao: {
+        observable() {
+          return rolesObservable
+        }
+      }
+    },
+    oldObservable,
+    view: {},
+    config: {
+      roles: ['owner'],
+      objects: () => [{ objectType: 'x', object: '1' }]
+    },
+    viewName: 'test view'
+  })
+}
+
+const client = { session: 's1', user: 'u1', roles: [] }
+const args = [{ objectType: 'x', object: '1' }, { client }]
+
+test('T3.1 accessible-true-forwards-set', async () => {
+  const roles = createRolesObservable()
+  const value = createValueObservable({ ok: true })
+  const observable = wrapWith(roles, () => value)
+  const proxy = observable(...args)
+  const got = []
+  proxy.observe({
+    set(v) { got.push(v) }
+  })
+  roles.set({ roles: ['owner'] })
+  assert.deepEqual(got[got.length - 1], { ok: true })
+})
+
+test('T3.2 accessible-false-emits-error', async () => {
+  const roles = createRolesObservable()
+  const value = createValueObservable({ ok: true })
+  const observable = wrapWith(roles, () => value)
+  const proxy = observable(...args)
+  let err
+  proxy.observe({
+    set() {},
+    error(e) { err = e }
+  })
+  roles.set({ roles: [] })
+  assert.equal(err, 'notAuthorized')
+})
+
+test('T3.3 accessible-flip-disposes-old-value', async () => {
+  const roles = createRolesObservable()
+  const value = createValueObservable({ ok: true })
+  const observable = wrapWith(roles, () => value)
+  const proxy = observable(...args)
+  proxy.observe({ set() {}, error() {} })
+  roles.set({ roles: ['owner'] })
+  assert.equal(value.disposeCount, 0)
+  roles.set({ roles: [] })
+  assert.ok(value.disposeCount >= 1)
+  assert.ok(value.isDisposed())
+})
+
+test('T3.4 proxy-dispose-disposes-both', async () => {
+  const roles = createRolesObservable()
+  const value = createValueObservable({ ok: true })
+  const observable = wrapWith(roles, () => value)
+  const proxy = observable(...args)
+  proxy.observe({ set() {} })
+  roles.set({ roles: ['owner'] })
+  proxy.dispose()
+  assert.equal(roles.unobserveCount, 1)
+  assert.ok(value.disposeCount >= 1)
+  assert.ok(value.isDisposed())
+})
+
+test('T3.5 proxy-dispose-before-value-resolve', async () => {
+  const roles = createRolesObservable()
+  const inner = createValueObservable({ delayed: true })
+  let resolve
+  const pending = new Promise(res => { resolve = res })
+  const observable = wrapWith(roles, () => pending)
+  const proxy = observable(...args)
+  proxy.observe({ set() {}, error() {} })
+  roles.set({ roles: ['owner'] })
+  proxy.dispose()
+  resolve(inner)
+  await new Promise(r => setImmediate(r))
+  await new Promise(r => setImmediate(r))
+  assert.equal(inner.disposeCount, 1)
+  assert.ok(inner.isDisposed())
+})
+
+test('T3.6 proxy-respawn-reobserves', async () => {
+  const roles = createRolesObservable()
+  const value = createValueObservable({ ok: true })
+  const observable = wrapWith(roles, () => value)
+  const proxy = observable(...args)
+  proxy.observe({ set() {} })
+  roles.set({ roles: ['owner'] })
+  assert.equal(roles.observeCount, 1)
+  proxy.dispose()
+  proxy.respawn()
+  assert.equal(roles.observeCount, 2)
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/access-control-service",
-  "version": "0.9.228",
+  "version": "0.9.230",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,8 +21,8 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.9.228"
+    "@live-change/framework": "^0.9.230"
   },
-  "gitHead": "fd47aa55100c5a25c3f52c899a79a663421037ff",
+  "gitHead": "dce3ca9bbe8c025874a4927dc1b273566d0bee67",
   "type": "module"
 }

package/wrapViewObservable.js

@@ -0,0 +1,96 @@
+import { ObservableValue, ObservableProxy, ObservablePromiseProxy } from '@live-change/dao'
+
+function safeDispose(observable) {
+  if (!observable) return
+  if (observable.isDisposed && observable.isDisposed()) return
+  try {
+    if (typeof observable.dispose === 'function') observable.dispose()
+  } catch {
+    // already torn down
+  }
+}
+
+/**
+ * Wrap a view.observable with access-control rolesPath on app.dao.
+ * Extracted so contract tests can mock app.dao / access without booting App.
+ */
+export function wrapViewObservable({
+  access,
+  app,
+  oldObservable,
+  view,
+  config,
+  viewName
+}) {
+  return (...args) => {
+    const [ properties, context ] = args
+    const { client } = context
+    const { objectType, object } = properties
+    const objects = [].concat(
+      config.objects ? config.objects(properties) :
+        ((objectType && object) ? [{ objectType, object }] : [])
+    )
+    if (objects.length === 0) {
+      console.warn(
+        'no objects for ' + (viewName || 'view') +
+        ' access control to work - only global roles will be checked'
+      )
+    }
+
+    const rolesPath = access.accessPath(client, objects)
+
+    const errorObservable = new ObservableValue()
+    errorObservable.handleError('notAuthorized')
+
+    const observableProxy = new ObservableProxy(null)
+
+    let valueObservable
+    let accessible
+    let rolesObserved = false
+
+    const rolesObservable = app.dao.observable(rolesPath)
+    const rolesObserver = () => {
+      const accessObject = rolesObservable.getValue()
+      const newAccessible = accessObject ? access.testRoles(config.roles, accessObject.roles) : false
+      if (newAccessible !== accessible) {
+        const previousValue = valueObservable
+        if (newAccessible === true) {
+          valueObservable = oldObservable.apply(view, args)
+          if (valueObservable && valueObservable.then) {
+            valueObservable = new ObservablePromiseProxy(valueObservable)
+          }
+        } else {
+          valueObservable = undefined
+        }
+        observableProxy.setTarget(newAccessible ? valueObservable : errorObservable)
+        if (previousValue && previousValue !== valueObservable) safeDispose(previousValue)
+        accessible = newAccessible
+      }
+    }
+    rolesObservable.observe(rolesObserver)
+    rolesObserved = true
+
+    const oldDispose = observableProxy.dispose.bind(observableProxy)
+    const oldRespawn = observableProxy.respawn.bind(observableProxy)
+    observableProxy.dispose = () => {
+      if (rolesObserved) {
+        try {
+          rolesObservable.unobserve(rolesObserver)
+        } catch {
+          // already torn down
+        }
+        rolesObserved = false
+      }
+      oldDispose()
+      safeDispose(valueObservable)
+    }
+    observableProxy.respawn = () => {
+      if (!rolesObserved) {
+        rolesObservable.observe(rolesObserver)
+        rolesObserved = true
+      }
+      oldRespawn()
+    }
+    return observableProxy
+  }
+}