@openparachute/vault 0.7.0-rc.9 → 0.7.2-rc.3

package/core/src/hooks.ts

@@ -372,6 +372,15 @@ export class HookRegistry {
 
     // Defer to a microtask so we unwind the caller's stack (and its
     // SQLite transaction, if any) before handlers run.
+    //
+    // Caveat (vault#589): under an ASYNC transaction that spans awaits (the
+    // atomic blow-away import wrapped in `transactionAsync`), the connection
+    // stays open across the microtask boundary. A handler that writes to the
+    // store BEFORE its first real `await` would `SAVEPOINT`-join that open
+    // transaction (rolled back with it). Every handler here is audited safe —
+    // it defers real work behind an `await` (semaphore acquire) and does no
+    // synchronous store write — but the invariant lives in txn.ts's header
+    // ("shared-connection invariant"), not just this comment; keep it true.
     queueMicrotask(() => {
       for (const hook of matches) {
         const task = this.runHandler(hook, event, note, store);

package/core/src/indexed-fields.test.ts

@@ -67,10 +67,13 @@ describe("indexed-fields: module", () => {
     expect(() => validateFieldName("'; DROP TABLE notes; --")).toThrow(IndexedFieldError);
   });
 
-  it("TYPE_MAP covers string/integer/boolean", () => {
+  it("TYPE_MAP covers string/integer/boolean/reference", () => {
     expect(TYPE_MAP.string).toBe("TEXT");
     expect(TYPE_MAP.integer).toBe("INTEGER");
     expect(TYPE_MAP.boolean).toBe("INTEGER");
+    // vault#typed-reference-field: `reference` stores like `string` — the
+    // metadata VALUE (an id/path/title) is what's indexed here.
+    expect(TYPE_MAP.reference).toBe("TEXT");
   });
 
   it("declareField creates column + index on first declaration", () => {

package/core/src/indexed-fields.ts

@@ -23,12 +23,17 @@ import { Database } from "bun:sqlite";
 // ---------------------------------------------------------------------------
 
 export type SqliteType = "TEXT" | "INTEGER";
-export type FieldType = "string" | "integer" | "boolean";
+// `reference` (vault#typed-reference-field) is stored as TEXT — same as
+// `string` — because the metadata VALUE (an id/path/title) is what's
+// indexed here; the resolved graph link is a separate concern maintained by
+// `core/src/store.ts`'s write path. See tag-schemas.ts's `VALID_FIELD_TYPES`.
+export type FieldType = "string" | "integer" | "boolean" | "reference";
 
 export const TYPE_MAP: Record<FieldType, SqliteType> = {
   string: "TEXT",
   integer: "INTEGER",
   boolean: "INTEGER",
+  reference: "TEXT",
 };
 
 export interface IndexedField {

package/core/src/links.ts

@@ -35,6 +35,28 @@ export function deleteLink(
   ).run(sourceId, targetId, relationship);
 }
 
+/**
+ * Delete every outbound link from `sourceId` carrying `relationship`,
+ * regardless of target. Used by the `reference`-field auto-link sync
+ * (core/src/store.ts's `syncReferenceFieldLinks`, vault#typed-reference-field)
+ * to re-establish "this field's link" as a single source of truth: rather
+ * than tracking the PRIOR resolved target to delete exactly one edge, the
+ * sync clears every edge under the field's relationship name and recreates
+ * at most one from the field's current value. This is safe because a
+ * `reference` field's relationship name is field-owned — a hand-authored
+ * `links` entry using the SAME relationship name on the SAME note is
+ * expected to be superseded by the field, not preserved alongside it.
+ */
+export function deleteLinksBySourceRelationship(
+  db: Database,
+  sourceId: string,
+  relationship: string,
+): void {
+  db.prepare(
+    "DELETE FROM links WHERE source_id = ? AND relationship = ?",
+  ).run(sourceId, relationship);
+}
+
 export function getLinks(
   db: Database,
   noteId: string,