@cero-base/core 0.8.2 → 0.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/core",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "cero p2p primitives — identity, storage, network, database, blobs, rpc, pairing.",
   "type": "module",
   "main": "./src/index.js",

package/src/database/index.js

@@ -71,6 +71,8 @@ export class Database extends ReadyResource {
     this.beforeHooks = new Map()
     this.afterHooks = new Map()
     this.updaters = new Set()
+    this.onApplyHooks = new Set()
+    this._applySeq = 0
     this.txQueue = null
   }
 
@@ -102,8 +104,11 @@ export class Database extends ReadyResource {
       optimistic: true,
       wakeup: this.network?.wakeup || undefined,
       open: (b) => HyperDB.bee2(b, this.spec.database, { autoUpdate: true }),
-      apply: (nodes, view, host) =>
-        (this.applyOverride || this.dispatcher.apply)(nodes, view, host),
+      apply: async (nodes, view, host) => {
+        const result = await (this.applyOverride || this.dispatcher.apply)(nodes, view, host)
+        if (this.onApplyHooks.size) this._observe(nodes)
+        return result
+      },
       update: async (db) => {
         await db.update()
         for (const fn of this.updaters) fn()
@@ -178,6 +183,49 @@ export class Database extends ReadyResource {
     return () => this.updaters.delete(fn)
   }
 
+  /**
+   * Observe every applied op — local AND replicated (apply processes the merged
+   * log). The callback receives `{ op, name, row, writerKey, seq }` and runs
+   * synchronously, so it must be cheap and non-blocking (enqueue and return).
+   * Gated: zero cost when no subscriber is registered. Returns a disposer.
+   *
+   * @param {(event: { op: string, name: string, row: any, writerKey: any, seq: number }) => void} fn
+   * @returns {() => void} disposer
+   */
+  onApply(fn) {
+    if (typeof fn !== 'function') return () => {}
+    this.onApplyHooks.add(fn)
+    return () => this.onApplyHooks.delete(fn)
+  }
+
+  _observe(nodes) {
+    for (const node of nodes) {
+      let event
+      try {
+        const { name, value } = this.spec.dispatch.decode(node.value)
+        const verb = name.slice(name.indexOf('/') + 1) // '@cero/set-messages' → 'set-messages'
+        const dash = verb.indexOf('-')
+        event = {
+          op: dash < 0 ? verb : verb.slice(0, dash),
+          name: dash < 0 ? verb : verb.slice(dash + 1),
+          row: value,
+          writerKey: node.key,
+          seq: this._applySeq++
+        }
+      } catch (err) {
+        safetyCatch(err)
+        continue
+      }
+      for (const fn of this.onApplyHooks) {
+        try {
+          fn(event)
+        } catch (err) {
+          safetyCatch(err)
+        }
+      }
+    }
+  }
+
   /**
    * Run all registered `before:op` hooks and emit the corresponding event.
    *

package/types/database/index.d.ts

@@ -69,6 +69,8 @@ export class Database extends ReadyResource {
     beforeHooks: Map<any, any>;
     afterHooks: Map<any, any>;
     updaters: Set<any>;
+    onApplyHooks: Set<any>;
+    _applySeq: number;
     txQueue: any[];
     _discovery: import("../network/discovery.js").Discovery;
     /** Open the underlying autobee, wire dispatcher + apply, attach to network. */
@@ -101,6 +103,23 @@ export class Database extends ReadyResource {
      * @returns {() => void} disposer
      */
     onUpdate(fn: () => void): () => void;
+    /**
+     * Observe every applied op — local AND replicated (apply processes the merged
+     * log). The callback receives `{ op, name, row, writerKey, seq }` and runs
+     * synchronously, so it must be cheap and non-blocking (enqueue and return).
+     * Gated: zero cost when no subscriber is registered. Returns a disposer.
+     *
+     * @param {(event: { op: string, name: string, row: any, writerKey: any, seq: number }) => void} fn
+     * @returns {() => void} disposer
+     */
+    onApply(fn: (event: {
+        op: string;
+        name: string;
+        row: any;
+        writerKey: any;
+        seq: number;
+    }) => void): () => void;
+    _observe(nodes: any): void;
     /**
      * Run all registered `before:op` hooks and emit the corresponding event.
      *