@openparachute/vault 0.4.4-rc.12 → 0.4.5

package/src/vault.test.ts

@@ -1702,6 +1702,162 @@ describe("HTTP /notes", async () => {
     expect(body.createdAt).toBe("2025-01-01T00:00:00.000Z");
   });
 
+  // ---- Extension field (vault#328) ----
+
+  test("POST /notes accepts extension and persists it", async () => {
+    const res = await handleNotes(
+      mkReq("POST", "/notes", {
+        content: "month,total\n2026-01,9000",
+        path: "Tabular/budget",
+        extension: "csv",
+      }),
+      store,
+      "",
+    );
+    expect(res.status).toBe(201);
+    const body = await res.json() as any;
+    expect(body.extension).toBe("csv");
+    const fetched = await store.getNote(body.id);
+    expect(fetched!.extension).toBe("csv");
+  });
+
+  test("POST /notes defaults extension to 'md' when omitted", async () => {
+    const res = await handleNotes(
+      mkReq("POST", "/notes", { content: "plain", path: "p" }),
+      store,
+      "",
+    );
+    const body = await res.json() as any;
+    expect(body.extension).toBe("md");
+  });
+
+  test("POST /notes rejects invalid extension with 400 invalid_extension", async () => {
+    const res = await handleNotes(
+      mkReq("POST", "/notes", { content: "x", extension: "CSV" }),
+      store,
+      "",
+    );
+    expect(res.status).toBe(400);
+    const body = await res.json() as any;
+    expect(body.error_type).toBe("invalid_extension");
+    expect(body.extension).toBe("CSV");
+  });
+
+  test("POST /notes rejects reserved 'parachute' prefix with 400", async () => {
+    const res = await handleNotes(
+      mkReq("POST", "/notes", { content: "x", extension: "parachute" }),
+      store,
+      "",
+    );
+    expect(res.status).toBe(400);
+    const body = await res.json() as any;
+    expect(body.error_type).toBe("invalid_extension");
+    expect(body.reason).toMatch(/reserved/);
+  });
+
+  test("PATCH /notes/:id changes extension", async () => {
+    const note = await store.createNote("hi", { id: "ext-patch", path: "p" });
+    const res = await handleNotes(
+      mkReq("PATCH", "/notes/ext-patch", {
+        extension: "mdx",
+        if_updated_at: note.updatedAt,
+      }),
+      store,
+      "/ext-patch",
+    );
+    expect(res.status).toBe(200);
+    const fetched = await store.getNote("ext-patch");
+    expect(fetched!.extension).toBe("mdx");
+  });
+
+  test("PATCH /notes/:id rejects invalid extension with 400", async () => {
+    const note = await store.createNote("hi", { id: "ext-bad", path: "p" });
+    const res = await handleNotes(
+      mkReq("PATCH", "/notes/ext-bad", {
+        extension: "foo.bar",
+        if_updated_at: note.updatedAt,
+      }),
+      store,
+      "/ext-bad",
+    );
+    expect(res.status).toBe(400);
+    const body = await res.json() as any;
+    expect(body.error_type).toBe("invalid_extension");
+  });
+
+  test("GET /notes?extension=csv filters by extension", async () => {
+    await store.createNote("md note", { path: "a" });
+    await store.createNote("csv note", { path: "b", extension: "csv" });
+    await store.createNote("yaml note", { path: "c", extension: "yaml" });
+    const res = await handleNotes(
+      mkReq("GET", "/notes?extension=csv&include_content=true"),
+      store,
+      "",
+    );
+    const body = await res.json() as any[];
+    expect(body).toHaveLength(1);
+    expect(body[0].path).toBe("b");
+  });
+
+  test("GET /notes?extension=csv&extension=yaml filters by array of extensions", async () => {
+    await store.createNote("md note", { path: "a" });
+    await store.createNote("csv note", { path: "b", extension: "csv" });
+    await store.createNote("yaml note", { path: "c", extension: "yaml" });
+    const res = await handleNotes(
+      mkReq("GET", "/notes?extension=csv&extension=yaml&include_content=true"),
+      store,
+      "",
+    );
+    const body = await res.json() as any[];
+    expect(body).toHaveLength(2);
+    expect(body.map((n) => n.path).sort()).toEqual(["b", "c"]);
+  });
+
+  test("PATCH /notes/:id if_missing=create honors extension", async () => {
+    const idOrPath = encodeURIComponent("Tabular/new-budget");
+    const res = await handleNotes(
+      mkReq("PATCH", `/notes/${idOrPath}`, {
+        content: "month,total\n2026-02,1000",
+        extension: "csv",
+        if_missing: "create",
+      }),
+      store,
+      `/${idOrPath}`,
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.created).toBe(true);
+    expect(body.extension).toBe("csv");
+  });
+
+  test("GET /notes?id=<path> returns 409 ambiguous_path when path matches multiple extensions (vault#330 S1)", async () => {
+    await store.createNote("# md", { path: "Foo", id: "foo-md" });
+    await store.createNote("a,b\n1,2", { path: "Foo", extension: "csv", id: "foo-csv" });
+    const res = await handleNotes(
+      mkReq("GET", "/notes?id=Foo"),
+      store,
+      "",
+    );
+    expect(res.status).toBe(409);
+    const body = await res.json() as any;
+    expect(body.error_type).toBe("ambiguous_path");
+    expect(body.path).toBe("Foo");
+    expect(body.candidates).toHaveLength(2);
+  });
+
+  test("GET /notes?id=Foo.csv resolves the explicit-extension form (vault#330 S1)", async () => {
+    await store.createNote("# md", { path: "Foo", id: "foo-md" });
+    await store.createNote("a,b\n1,2", { path: "Foo", extension: "csv", id: "foo-csv" });
+    const res = await handleNotes(
+      mkReq("GET", "/notes?id=Foo.csv"),
+      store,
+      "",
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.id).toBe("foo-csv");
+  });
+
   test("POST /notes/:id/attachments accepts mimeType (camelCase) in body", async () => {
     const n = await store.createNote("x", { id: "x" });
     const res = await handleNotes(
@@ -1883,36 +2039,30 @@ describe("HTTP /notes", async () => {
   });
 
   // -------------------------------------------------------------------------
-  // Empty-note guard + batch cap (#213) — runaway-client protection
+  // Empty content is a valid state (vault#323)
   // -------------------------------------------------------------------------
-
-  describe("empty-note guard (#213)", async () => {
-    test("POST bare {} body → 400 EmptyNoteError", async () => {
+  // Skeleton notes, drafts, organizing-only notes, and capture-then-fill
+  // flows all legitimately produce empty-content rows. The earlier #213
+  // guard rejected `content + path both absent` — we no longer enforce
+  // it because real vaults carry such rows and the round-trip import
+  // has to accept them.
+
+  describe("empty content is valid (vault#323)", async () => {
+    test("POST bare {} body → 201", async () => {
       const res = await handleNotes(mkReq("POST", "/notes", {}), store, "");
-      expect(res.status).toBe(400);
-      const body = await res.json() as any;
-      expect(body.error_type).toBe("empty_note");
-      expect(body.error).toBe("EmptyNoteError");
+      expect(res.status).toBe(201);
     });
 
-    test("POST batch with one empty entry → 400 EmptyNoteError, NOTHING created (atomic)", async () => {
-      // Pre-validate the batch before any DB writes so a mixed batch with one
-      // bad entry rolls back the whole call. The runaway-client signature
-      // (#213) is "thousands of empties" — partial-create semantics would
-      // still leak the prefix on every burst. Atomic is the only safe shape.
+    test("POST batch with mixed empty + content entries → 201, all created", async () => {
       const beforeCount = (await store.queryNotes({ path: "ok-1" })).length;
       const res = await handleNotes(
-        mkReq("POST", "/notes", { notes: [{ path: "ok-1" }, {}] }),
+        mkReq("POST", "/notes", { notes: [{ path: "ok-1" }, {}, { content: "third" }] }),
         store,
         "",
       );
-      expect(res.status).toBe(400);
-      const body = await res.json() as any;
-      expect(body.error_type).toBe("empty_note");
-      expect(body.item_index).toBe(1);
-      // ok-1 must NOT have been created — atomic rollback.
+      expect(res.status).toBe(201);
       const afterCount = (await store.queryNotes({ path: "ok-1" })).length;
-      expect(afterCount).toBe(beforeCount);
+      expect(afterCount).toBe(beforeCount + 1);
     });
 
     test("POST single content-only (path absent) → 201", async () => {
@@ -1924,9 +2074,7 @@ describe("HTTP /notes", async () => {
       expect(res.status).toBe(201);
     });
 
-    test("POST single path-only (content absent) → 201, no warning log", async () => {
-      // Path-only is a wikilink placeholder / `_schemas/*` shape — must
-      // remain accepted (per #223 design Q3).
+    test("POST single path-only (content absent) → 201", async () => {
       const res = await handleNotes(
         mkReq("POST", "/notes", { path: "wiki/placeholder" }),
         store,
@@ -1935,8 +2083,8 @@ describe("HTTP /notes", async () => {
       expect(res.status).toBe(201);
     });
 
-    test("PATCH that would clear both content and path → 400 EmptyNoteError", async () => {
-      const note = await store.createNote("starts with content", { id: "ep1" });
+    test("PATCH that clears both content and path → 200", async () => {
+      await store.createNote("starts with content", { id: "ep1" });
       const updated = await store.getNote("ep1");
       const res = await handleNotes(
         mkReq("PATCH", "/notes/ep1", {
@@ -1947,14 +2095,11 @@ describe("HTTP /notes", async () => {
         store,
         "/ep1",
       );
-      expect(res.status).toBe(400);
-      const body = await res.json() as any;
-      expect(body.error_type).toBe("empty_note");
-      expect(body.note_id).toBe("ep1");
+      expect(res.status).toBe(200);
     });
 
     test("PATCH that clears content but preserves path → 200", async () => {
-      const note = await store.createNote("body", { id: "ep2", path: "p2" });
+      await store.createNote("body", { id: "ep2", path: "p2" });
       const updated = await store.getNote("ep2");
       const res = await handleNotes(
         mkReq("PATCH", "/notes/ep2", {
@@ -1970,8 +2115,7 @@ describe("HTTP /notes", async () => {
 
   describe("batch atomicity (#236)", async () => {
     test("POST batch where mid-item triggers PATH_CONFLICT → 409, NOTHING created", async () => {
-      // The empty-note pre-walk catches `{}` before any DB write (#213); a
-      // path-conflict only surfaces on the actual INSERT, mid-loop. Without
+      // A path-conflict only surfaces on the actual INSERT, mid-loop. Without
       // the BEGIN/COMMIT wrap the prefix would have already landed by then.
       await store.createNote("existing", { path: "taken" });
       const beforeIds = (await store.queryNotes({})).map((n) => n.id).sort();
@@ -2998,6 +3142,105 @@ describe("HTTP PATCH /notes/:idOrPath if_missing=create (vault#309)", async () =
     const body = await res.json() as any;
     expect(body.created).toBe(false);
   });
+
+  // vault#321 F2 — REST create-on-missing branch applies links.add.
+  // MCP's create branch already did; REST was missing the
+  // link-creation pass entirely. Cross-surface inconsistency Gitcoin
+  // would trip on if they migrated from MCP to REST. The new pass
+  // mirrors MCP exactly (links.add applied, links.remove ignored,
+  // missing targets skip silently).
+  test("if_missing=create + links.add creates typed-link rows (vault#321 F2)", async () => {
+    // Two pre-existing target notes (different ids + paths) so the
+    // source can fan out to both.
+    await store.createNote("target A", { id: "t-a-321", path: "Targets/A" });
+    await store.createNote("target B", { id: "t-b-321", path: "Targets/B" });
+
+    const res = await handleNotes(
+      mkReq("PATCH", `/notes/${encodeURIComponent("Inbox/source-321")}`, {
+        content: "source body",
+        if_missing: "create",
+        links: {
+          add: [
+            { target: "t-a-321", relationship: "derived-from" },
+            { target: "Targets/B", relationship: "responds-to", metadata: { weight: 5 } },
+          ],
+        },
+      }),
+      store,
+      `/${encodeURIComponent("Inbox/source-321")}`,
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.created).toBe(true);
+
+    // Link rows exist + resolved targets correctly. We look up by the
+    // source's note id (the body returned by the create branch).
+    const sourceId = body.id as string;
+    const outboundLinks = await store.getLinks(sourceId, { direction: "outbound" });
+    const derivedFrom = outboundLinks.find((l) => l.relationship === "derived-from");
+    expect(derivedFrom).toBeDefined();
+    expect(derivedFrom!.targetId).toBe("t-a-321");
+
+    const respondsTo = outboundLinks.find((l) => l.relationship === "responds-to");
+    expect(respondsTo).toBeDefined();
+    expect(respondsTo!.targetId).toBe("t-b-321");
+    expect(respondsTo!.metadata).toEqual({ weight: 5 });
+  });
+
+  test("if_missing=create + links.add silently skips when target does not exist (vault#321 F2)", async () => {
+    // Mirrors MCP: missing target → silent skip, no error. Sync loops
+    // that declare links to not-yet-imported notes shouldn't abort
+    // the whole upsert.
+    const res = await handleNotes(
+      mkReq("PATCH", `/notes/${encodeURIComponent("Inbox/source-missing-321")}`, {
+        content: "x",
+        if_missing: "create",
+        links: { add: [{ target: "does-not-exist", relationship: "derived-from" }] },
+      }),
+      store,
+      `/${encodeURIComponent("Inbox/source-missing-321")}`,
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.created).toBe(true);
+    // The note is created. No links resolved.
+    const links = await store.getLinks(body.id, { direction: "outbound" });
+    expect(links.filter((l) => l.relationship === "derived-from")).toHaveLength(0);
+  });
+
+  // vault#321 F3 — schema-conflict warning on REST create branch
+  // (mirror of the MCP test in core.test.ts). Same conflict-detection
+  // path runs on both surfaces via attachValidationStatus, but we pin
+  // both ends explicitly so a regression on either side surfaces
+  // immediately.
+  test("schema-conflict warning surfaces on REST create branch (vault#321 F3)", async () => {
+    await store.upsertTagSchema("kpi-rest-321", {
+      fields: { count: { type: "integer" } },
+    });
+    await store.upsertTagSchema("metric-rest-321", {
+      fields: { count: { type: "string" } }, // conflicting
+    });
+    const res = await handleNotes(
+      mkReq("PATCH", `/notes/${encodeURIComponent("Inbox/conflict-321")}`, {
+        content: "x",
+        if_missing: "create",
+        tags: ["kpi-rest-321", "metric-rest-321"],
+        metadata: { count: 5 },
+      }),
+      store,
+      `/${encodeURIComponent("Inbox/conflict-321")}`,
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.created).toBe(true);
+    const conflict = body.validation_status.warnings.find(
+      (w: any) => w.reason === "schema_conflict",
+    );
+    expect(conflict).toBeDefined();
+    expect(conflict.field).toBe("count");
+    expect(conflict.schema).toBe("kpi-rest-321");
+    expect(conflict.loser_schema).toBe("metric-rest-321");
+  });
 });
 
 describe("HTTP /tags", async () => {
@@ -3192,6 +3435,25 @@ describe("HTTP /find-path", async () => {
     const res = await handleFindPath(mkReq("GET", "/find-path?source=a"), store);
     expect(res.status).toBe(400);
   });
+
+  test("returns 409 ambiguous_path when source path is ambiguous (vault#331 N1)", async () => {
+    // Two notes share path "Foo" differing by extension. handleFindPath's
+    // resolveNote(source) would otherwise non-deterministically pick
+    // one; post-#331 it throws AmbiguousPathError and the handler's
+    // catch surfaces a structured 409 (same shape as handleNotes).
+    await store.createNote("# md", { id: "foo-md", path: "Foo" });
+    await store.createNote("a,b\n1,2", { id: "foo-csv", path: "Foo", extension: "csv" });
+    await store.createNote("target", { id: "target" });
+    const res = await handleFindPath(
+      mkReq("GET", "/find-path?source=Foo&target=target"),
+      store,
+    );
+    expect(res.status).toBe(409);
+    const body = await res.json() as any;
+    expect(body.error_type).toBe("ambiguous_path");
+    expect(body.path).toBe("Foo");
+    expect(body.candidates).toHaveLength(2);
+  });
 });
 
 describe("stateless MCP transport", async () => {