@pryv/monitor 3.0.2 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pryv/monitor",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "Extends `pryv` with event-driven notifications for changes on a Pryv.io account",
   "keywords": [
     "Pryv",

package/src/Monitor.js

@@ -163,6 +163,30 @@ class Monitor extends EventEmitter {
     return this.states.started;
   }
 
+  /**
+   * Plan 66: register a handler for the server's fine-grained
+   * `accessUpdated` event. Fires whenever a Pryv.io ≥ 2.0.0-pre.X server
+   * emits the event after a successful `accesses.update` — payload is
+   * `{ type: 'access-updated', accessId: '<base>:<serial>', serial }`.
+   *
+   * Requires `Monitor.UpdateMethod.Socket` to be active (the event
+   * is server-pushed via `@pryv/socket.io`). With other update methods
+   * (e.g. `EventsTimer` polling), the handler will never fire —
+   * polling-based consumers should call `connection.accessInfo(true)`
+   * themselves when they need to refresh the cache.
+   *
+   * The underlying `connection.socket` already busts the
+   * `connection.accessInfo` cache when this event fires, so the next
+   * `connection.accessInfo()` call returns the freshly-fetched copy.
+   *
+   * @param {Function} handler - called with `(payload)` on each event
+   * @returns {Monitor} this (chainable)
+   */
+  onAccessUpdated (handler) {
+    this.on('accessUpdated', handler);
+    return this;
+  }
+
   /**
    * @private
    * Called by UpdateMethod to share cross references

package/src/UpdateMethod/Socket.js

@@ -23,7 +23,25 @@ class Socket extends UpdateMethod {
     this.socket = await this.monitor.connection.socket.open();
     this.socket.on('eventsChanged', () => { this.monitor.updateEvents(); });
     this.socket.on('streamsChanged', () => { this.monitor.updateStreams(); });
-    this.socket.on('error', (error) => { this.monitor.emit(Changes.ERROR, error); });
+    // Plan 66: re-emit the server's fine-grained `accessUpdated` event
+    // on the Monitor itself so consumers can subscribe via
+    // `monitor.onAccessUpdated(handler)`. The underlying SocketIO has
+    // already busted the connection's accessInfo cache; the payload
+    // carries the new composite accessId + serial for fine-grained
+    // reactions.
+    this.socket.on('accessUpdated', (payload) => {
+      this.monitor.emit('accessUpdated', payload);
+    });
+    this.socket.on('error', (error) => {
+      this.monitor.emit(Changes.ERROR, error);
+      // If the underlying socket.io-client transport has been torn down
+      // (i.e. SocketIO emitted 'error' after reconnect_failed), drop our
+      // reference so a future Changes.READY can rebuild instead of
+      // short-circuiting on the cached, dead handle.
+      if (this.socket && !this.socket._io) {
+        this.socket = null;
+      }
+    });
   }
 
   async stop () {

package/src/index.d.ts

@@ -96,6 +96,14 @@ declare module 'pryv' {
      */
     stop(): Monitor;
 
+    /**
+     * Plan 66: register a handler for the server's fine-grained
+     * `accessUpdated` event. Requires `Monitor.UpdateMethod.Socket`.
+     * The underlying `connection.socket` busts the
+     * `connection.accessInfo` cache before this fires.
+     */
+    onAccessUpdated(handler: (payload: { type: 'access-updated', accessId: string, serial: number }) => void): Monitor;
+
     /**
      * True when the monitor has been started and not yet stopped.
      */