@openparachute/vault 0.6.4-rc.2 → 0.6.4-rc.4

package/src/triggers.test.ts

@@ -95,6 +95,39 @@ describe("buildPredicate", () => {
     expect(pred(makeNote({ tags: ["reader"] }))).toBe(false);
     expect(pred(makeNote({ tags: ["reader", "important"] }))).toBe(true);
   });
+
+  // Value-matched metadata grammar (vault#299 Part B).
+  it("metadata eq: fires only when the field equals the value", () => {
+    const pred = buildPredicate({ metadata: { state: { eq: "published" } } }, "publish_hook");
+    expect(pred(makeNote({ metadata: { state: "published" } }))).toBe(true);
+    expect(pred(makeNote({ metadata: { state: "drafted" } }))).toBe(false);
+    expect(pred(makeNote({ metadata: {} }))).toBe(false); // absent → no fire
+  });
+
+  it("metadata in: fires on membership", () => {
+    const pred = buildPredicate({ metadata: { state: { in: ["produced", "published"] } } }, "h");
+    expect(pred(makeNote({ metadata: { state: "produced" } }))).toBe(true);
+    expect(pred(makeNote({ metadata: { state: "idea" } }))).toBe(false);
+  });
+
+  it("metadata combines with tag + presence filters (all must hold)", () => {
+    const pred = buildPredicate(
+      { tags: ["piece"], metadata: { state: { eq: "published" } }, missing_metadata: ["notified_at"] },
+      "h",
+    );
+    expect(pred(makeNote({ tags: ["piece"], metadata: { state: "published" } }))).toBe(true);
+    // right state, wrong tag.
+    expect(pred(makeNote({ tags: ["other"], metadata: { state: "published" } }))).toBe(false);
+    // right tag + state but already notified.
+    expect(
+      pred(makeNote({ tags: ["piece"], metadata: { state: "published", notified_at: "x" } })),
+    ).toBe(false);
+  });
+
+  it("a malformed operator never throws from the predicate (treated as no-match)", () => {
+    const pred = buildPredicate({ metadata: { state: { bogus: "x" } as any } }, "h");
+    expect(pred(makeNote({ metadata: { state: "published" } }))).toBe(false);
+  });
 });
 
 describe("registerTriggers — dispatch modes", async () => {

package/src/triggers.ts

@@ -30,6 +30,7 @@ import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
 import crypto from "node:crypto";
 import type { Note, Store, Attachment } from "../core/src/types.ts";
 import type { HookRegistry, HookEvent, NoteHookPayload } from "../core/src/hooks.ts";
+import { matchesOperator } from "../core/src/query-operators.ts";
 import type { TriggerConfig, TriggerWhen } from "./config.ts";
 import type { StoredTrigger } from "../core/src/triggers-store.ts";
 import { getVaultNameForStore } from "./vault-store.ts";
@@ -106,6 +107,22 @@ export function buildPredicate(when: TriggerWhen, triggerName: string): (note: N
       }
     }
 
+    // Value-matched metadata filter (vault#299 Part B). Each field's
+    // operator-object is evaluated against the note's live metadata with the
+    // SAME engine query-notes uses. ALL fields must match (AND). A malformed
+    // operator throws at registration-time validation, not here — by the time
+    // the predicate runs the shape is known-good, but we guard defensively so
+    // a bad config can never crash the hook dispatch loop (treat as no-match).
+    if (when.metadata) {
+      for (const [field, opObj] of Object.entries(when.metadata)) {
+        try {
+          if (!matchesOperator(field, meta?.[field], opObj)) return false;
+        } catch {
+          return false;
+        }
+      }
+    }
+
     return true;
   };
 }