@voxgig/build 4.3.0 → 4.11.0

package/tm/web/web/src/api.js.frag

@@ -0,0 +1,92 @@
+// Thin client over the Seneca bus.
+//
+// EVERY message the browser sends is an aim:web message: that is the only
+// namespace the backend gateway accepts (see backend/src/env/web/web.ts),
+// and each one is a declared proxy that forwards to the real service
+// message. Entity CRUD still lands on the ONE generic backend service, so
+// the same four calls serve every entity in the model.
+
+import { bus } from './bus.js'
+
+// ---- generic entity CRUD ------------------------------------------------
+
+async function list(ent, q) {
+  const r = await bus.post({ aim: 'web', on: 'ent', cmd: 'list', ent, q: q || {} })
+  return (r && r.ok && r.list) || []
+}
+
+async function load(ent, id) {
+  const r = await bus.post({ aim: 'web', on: 'ent', cmd: 'load', ent, id })
+  return r && r.ok ? r.item : null
+}
+
+async function save(ent, item) {
+  return bus.post({ aim: 'web', on: 'ent', cmd: 'save', ent, item })
+}
+
+async function remove(ent, id) {
+  return bus.post({ aim: 'web', on: 'ent', cmd: 'remove', ent, id })
+}
+
+// Users, for reference pickers (read-only, public fields).
+async function users() {
+  return list('sys/user')
+}
+
+// ---- auth / settings ----------------------------------------------------
+
+async function loadAuth() {
+  return bus.post('aim:web,on:auth,load:auth')
+}
+
+async function signin(email, password) {
+  return bus.post('aim:web,on:auth,signin:user', { email, password })
+}
+
+async function signout() {
+  return bus.post('aim:web,on:auth,signout:user')
+}
+
+async function changePass(password) {
+  return bus.post({ aim: 'web', on: 'auth', change: 'pass', password })
+}
+
+async function updateUser(data) {
+  return bus.post({ aim: 'web', on: 'auth', update: 'user', data })
+}
+
+async function remindPass(email) {
+  return bus.post({ aim: 'web', on: 'auth', remind: 'pass', email })
+}
+
+// ---- API access keys (REST API auth; Settings & security) ---------------
+
+async function createApikey(name) {
+  return bus.post({ aim: 'web', on: 'auth', create: 'apikey', name })
+}
+
+async function listApikeys() {
+  return bus.post({ aim: 'web', on: 'auth', list: 'apikey' })
+}
+
+async function revokeApikey(id) {
+  return bus.post({ aim: 'web', on: 'auth', revoke: 'apikey', id })
+}
+
+export {
+  list,
+  load,
+  save,
+  remove,
+  users,
+  loadAuth,
+  signin,
+  signout,
+  changePass,
+  updateUser,
+  remindPass,
+  createApikey,
+  listApikeys,
+  revokeApikey,
+}
+

package/tm/web/web/src/bus.js.frag

@@ -1,14 +1,14 @@
 // The browser-side Seneca service bus. All component state and all
 // backend communication flow through messages on this bus:
 //
-//   aim:*             -> the backend gateway (/seneca) via the
+//   aim:web,*         -> the backend gateway (/seneca) via the
 //                        seneca-browser fetch transport (cookie auth)
 //   cmp:*             -> local component plugins (state)
 //
 // Cross-component notification uses the tiny `evt` plugin below:
 // components post cmp:bus,emit:<name> and subscribe with onEvent().
 
-/* global Seneca */
+/* global Seneca, SenecaBrowserStore, SenecaBrowserDebug */
 
 const bus = Seneca({
   legacy: false,
@@ -23,34 +23,56 @@ const bus = Seneca({
   },
 })
   .test()
-  .client({ type: 'browser', pin: 'aim:*' })
-
-
-// Event fanout: seneca actions have single handlers, so the bus plugin
-// keeps a listener registry for UI notification.
-const listeners = {}
-
-bus.use(function evt() {
-  this.add('cmp:bus,emit:evt', function (msg, reply) {
-    const subs = listeners[msg.name] || []
-    for (const fn of subs) {
-      try {
-        fn(msg.data || {})
-      }
-      catch (e) {
-        console.error('evt listener failed', msg.name, e)
-      }
-    }
-    reply({ ok: true, count: subs.length })
+  .client({ type: 'browser', pin: 'aim:web' })
+
+
+// Transparent state cache (Redux-like): caches aim:web query results and
+// invalidates on writes, so repeated reads are served without a round-trip.
+// Registered AFTER .client() so the aim:web pin actions exist to be wrapped.
+if ('undefined' !== typeof SenecaBrowserStore) {
+  bus.use(SenecaBrowserStore, {
+    pin: 'aim:web',
+    // Defaults plus 'revoke': aim:web,on:auth,revoke:apikey must
+    // invalidate the cached list:apikey reads.
+    write: ['save', 'remove', 'update', 'delete', 'create', 'done', 'set', 'add', 'revoke'],
   })
+}
+
+// In-window devtools: a resizable/hideable pop-up showing live Seneca
+// message flows, config, and (via the store plugin above) the cache tree.
+// aim:web messages are the remote (backend) calls. Loaded as a global script
+// in index.html; guarded so a missing bundle never breaks the app.
+if ('undefined' !== typeof SenecaBrowserDebug) {
+  bus.use(SenecaBrowserDebug, { remotePins: 'aim:web' })
+}
+
+
+// Event fanout, unified on Seneca messages: cross-component events use the
+// bus's own sub/act. Unlike a plain `add` (single handler), `sub` allows
+// many observers per pattern - so it IS the pub/sub primitive. A no-op sink
+// action lets `act` resolve; observers subscribe via `sub`. This is the same
+// mechanism reactivity uses (see @seneca/browser-store's changed:* events).
+bus.add('cmp:evt', function (msg, reply) {
+  reply()
 })
 
 function onEvent(name, fn) {
-  (listeners[name] = listeners[name] || []).push(fn)
+  bus.sub('cmp:evt,name:' + name, function (msg) {
+    fn(msg.data || {})
+  })
 }
 
 function emit(name, data) {
-  bus.post('cmp:bus,emit:evt', { name, data })
+  bus.act('cmp:evt,name:' + name, { data })
+}
+
+
+// Avoid cross-user staleness: drop all cached queries whenever auth changes
+// (sign in / sign out), since cached results are principal-scoped.
+if ('undefined' !== typeof SenecaBrowserStore) {
+  onEvent('auth', function () {
+    bus.act('sys:browser-store,clear:store', function () {})
+  })
 }
 
 
@@ -59,3 +81,4 @@ export {
   onEvent,
   emit,
 }
+