benjivers/notes Public Public: anyone can read this; nobody can change it.

import { expect, test } from "bun:test";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { addNote, deleteNote, getNote, listNotes, searchNotes, updateNote } from "./actions.ts";

import { openDb } from "./db.ts";

import {

  cleanFolder,

  createSpace,

  deleteSpace,

  fileOf,

  folderOf,

  joinSpace,

  mySpaces,

  removeMember,

  setLink,

} from "./spaces.ts";

import { blobOid, syncSpace, type Entry, type Forge } from "./sync.ts";

// @ts-ignore — plain JS, shared with the browser.

import * as md from "../static/md.js";

import type { Who } from "./who.ts";

const db = openDb(mkdtempSync(join(tmpdir(), "app-spaces-")));

const ben: Who = { role: "admin", id: "1", name: "ben" };

const sam: Who = { role: "user", id: "acct:7", name: "sam" };

const eve: Who = { role: "user", id: "9", name: "eve" };

const must = <T>(r: { ok: true; value: T } | { ok: false; message: string }): T => {

  if (!r.ok) throw new Error(r.message);

  return r.value;

};

/** A repository in memory, behind the same four calls the forge answers. */

function fakeForge(files: Record<string, string> = {}) {

  const tree = new Map(Object.entries(files));

  let head = tree.size === 0 ? null : "c0";

  let n = 0;

  const commits: { message: string; files: { path: string; content: string | null }[] }[] = [];

  const forge: Forge = {

    async head() {

      return head;

    },

    async list(_repo, _ref, path) {

      const prefix = path === "" ? "" : `${path}/`;

      const seen = new Map<string, Entry>();

      for (const [p, content] of tree) {

        if (!p.startsWith(prefix)) continue;

        const rest = p.slice(prefix.length);

        const name = rest.split("/")[0]!;

        if (rest.includes("/")) seen.set(name, { name, type: "tree", oid: `t-${name}`, size: -1 });

        else seen.set(name, { name, type: "blob", oid: blobOid(content), size: content.length });

      }

      return seen.size === 0 && path !== "" ? null : [...seen.values()];

    },

    async read(_repo, _ref, path) {

      const content = tree.get(path);

      if (content === undefined) throw new Error(`no ${path}`);

      return content;

    },

    async commit(_repo, _branch, message, changes) {

      for (const f of changes) f.content === null ? tree.delete(f.path) : tree.set(f.path, f.content);

      commits.push({ message, files: changes });

      head = `c${++n}`;

      return head;

    },

  };

  return {

    forge,

    tree,

    commits,

    /** Someone pushes to the repository, outside the app. */

    push(changes: Record<string, string | null>) {

      for (const [p, c] of Object.entries(changes)) c === null ? tree.delete(p) : tree.set(p, c);

      head = `x${++n}`;

    },

  };

}

test("only an app admin connects a repository; a join link lets someone in, and only into that folder", () => {

  const refused = createSpace(db, sam, { name: "Nope", repo: "sam/x", folder: "docs" });

  expect(refused.ok).toBe(false);

  if (!refused.ok) expect(refused.error).toBe("forbidden");

  expect(createSpace(db, ben, { name: "Bad", repo: "not a repo" }).ok).toBe(false);

  expect(createSpace(db, ben, { name: "Bad", repo: "ben/x", folder: "../etc" }).ok).toBe(false);

  const space = must(createSpace(db, ben, { name: "Brainstorm", repo: "ben/brainstorm", folder: "/docs/" }));

  expect(space.folder).toBe("docs");

  expect(space.branch).toBe("main");

  expect(mySpaces(db, ben).map((s) => s.id)).toEqual([space.id]);

  expect(mySpaces(db, sam)).toEqual([]);

  const mine = must(addNote(db, ben, { title: "My own thoughts" }));

  const shared = must(addNote(db, ben, { title: "Pricing", space: space.id }));

  expect(shared.path).toBe("docs/Pricing.md");

  // A stranger can't see the folder or its notes, by id or by list.

  expect(getNote(db, sam, { id: shared.id }).ok).toBe(false);

  expect(listNotes(db, sam, { space: space.id }).ok).toBe(false);

  expect(addNote(db, sam, { title: "sneaky", space: space.id }).ok).toBe(false);

  must(joinSpace(db, sam, { code: space.join_code! }));

  expect(must(listNotes(db, sam, { space: space.id })).map((n) => n.title)).toEqual(["Pricing"]);

  expect(getNote(db, sam, { id: shared.id }).ok).toBe(true);

  // …and still nothing of Ben's own.

  expect(getNote(db, sam, { id: mine.id }).ok).toBe(false);

  expect(must(listNotes(db, sam)).map((n) => n.id)).not.toContain(mine.id);

  // Shared notes never show in anyone's own vault, Ben's included.

  expect(must(listNotes(db, ben)).map((n) => n.id)).not.toContain(shared.id);

  expect(must(searchNotes(db, ben, { q: "Pricing" }))).toEqual([]);

  expect(must(searchNotes(db, sam, { q: "Pricing", space: space.id })).length).toBe(1);

  // Sam writes; the note says so.

  const edited = must(updateNote(db, sam, { id: shared.id, body: "per seat?" }));

  expect(edited.author_name).toBe("sam");

  // The link off, nobody new gets in; the owner removes a member; the owner can't be removed.

  const off = must(setLink(db, ben, { id: space.id, on: false }));

  expect(joinSpace(db, eve, { code: space.join_code! }).ok).toBe(false);

  expect(off.join_code).toBeNull();

  expect(setLink(db, sam, { id: space.id, on: true }).ok).toBe(false);

  expect(removeMember(db, sam, { id: space.id, member: ben.id }).ok).toBe(false);

  must(removeMember(db, ben, { id: space.id, member: sam.id }));

  expect(getNote(db, sam, { id: shared.id }).ok).toBe(false);

  must(deleteSpace(db, ben, { id: space.id }));

  expect(getNote(db, ben, { id: shared.id }).ok).toBe(false);

  expect(getNote(db, ben, { id: mine.id }).ok).toBe(true);

});

test("a shared note's title is a file name, its folder a path; renames and moves carry the file", () => {

  const space = must(createSpace(db, ben, { name: "Paths", repo: "ben/paths", folder: "docs" }));

  expect(addNote(db, ben, { title: "a:b", space: space.id }).ok).toBe(false);

  const deep = must(addNote(db, ben, { title: "ideas/q4/Launch", space: space.id }));

  expect(deep.title).toBe("Launch");

  expect(deep.path).toBe("docs/ideas/q4/Launch.md");

  expect(folderOf(space, deep.path!)).toBe("ideas/q4");

  const renamed = must(updateNote(db, ben, { id: deep.id, title: "Launch plan" }));

  expect(renamed.path).toBe("docs/ideas/q4/Launch plan.md");

  const moved = must(updateNote(db, ben, { id: deep.id, folder: "archive" }));

  expect(moved.path).toBe("docs/archive/Launch plan.md");

  expect(must(updateNote(db, ben, { id: deep.id, folder: "" })).path).toBe("docs/Launch plan.md");

  expect(cleanFolder(" a / b ").ok && must(cleanFolder(" a / b "))).toBe("a/b");

  expect(fileOf({ folder: "" }, "", "Top")).toBe("Top.md");

});

test("someone else saved first: new words are a conflict, not an overwrite", async () => {

  const space = must(createSpace(db, ben, { name: "Race", repo: "ben/race" }));

  must(joinSpace(db, sam, { code: space.join_code! }));

  const note = must(addNote(db, ben, { title: "Plan", space: space.id, body: "v1" }));

  await Bun.sleep(3); // updated_at is to the millisecond

  const theirs = must(updateNote(db, sam, { id: note.id, body: "sam's v2", base: note.updated_at }));

  const mine = updateNote(db, ben, { id: note.id, body: "ben's v2", base: note.updated_at });

  expect(mine.ok).toBe(false);

  if (!mine.ok) expect(mine.error).toBe("conflict");

  expect(must(getNote(db, ben, { id: note.id })).body).toBe("sam's v2");

  // Written against what is there now, it goes through.

  expect(must(updateNote(db, ben, { id: note.id, body: "ben's v3", base: theirs.updated_at })).body).toBe("ben's v3");

});

test("sync reads the folder, commits what is written here, and takes what is pushed there", async () => {

  const repo = fakeForge({

    "README.md": "# not in the folder",

    "docs/Ideas.md": "---\ntags: [brainstorm, q4]\n---\nSee [[Pricing]].",

    "docs/research/Pricing.md": "per seat? #money",

    "docs/research/chart.png": "binary",

    "docs/.obsidian/workspace.md": "editor settings",

  });

  const space = must(createSpace(db, ben, { name: "Synced", repo: "ben/synced", folder: "docs" }));

  const first = await syncSpace(db, repo.forge, space.id);

  expect(first.pulled).toBe(2);

  const notes = () => must(listNotes(db, ben, { space: space.id }));

  const byTitle = (t: string) => notes().find((n) => n.title === t)!;

  expect(notes().map((n) => n.path).sort()).toEqual(["docs/Ideas.md", "docs/research/Pricing.md"]);

  expect(md.tags(byTitle("Ideas").body).sort()).toEqual(["brainstorm", "q4"]);

  // Nothing changed here, so nothing is committed.

  expect((await syncSpace(db, repo.forge, space.id)).pushed).toBe(0);

  expect(repo.commits).toEqual([]);

  // Written, made, renamed and removed here → one commit.

  must(updateNote(db, ben, { id: byTitle("Ideas").id, body: "See [[Pricing]] and [[Naming]]." }));

  must(addNote(db, ben, { title: "Naming", space: space.id, folder: "research", body: "names" }));

  must(updateNote(db, ben, { id: byTitle("Pricing").id, title: "Pricing model" }));

  const wrote = await syncSpace(db, repo.forge, space.id);

  expect(repo.commits.length).toBe(1);

  expect(repo.commits[0]!.message).toContain("Written in notes by ben");

  expect(wrote.pushed).toBe(4);

  expect([...repo.tree.keys()].sort()).toEqual([

    "README.md",

    "docs/.obsidian/workspace.md",

    "docs/Ideas.md",

    "docs/research/Naming.md",

    "docs/research/Pricing model.md",

    "docs/research/chart.png",

  ]);

  expect(repo.tree.get("docs/Ideas.md")).toBe("See [[Pricing model]] and [[Naming]].");

  // The next read finds our own commit and changes nothing.

  expect((await syncSpace(db, repo.forge, space.id)).pulled).toBe(0);

  must(deleteNote(db, ben, { id: byTitle("Naming").id }));

  await syncSpace(db, repo.forge, space.id);

  expect(repo.tree.has("docs/research/Naming.md")).toBe(false);

  // Someone pushes: a change, a new file, a removal.

  repo.push({

    "docs/Ideas.md": "Rewritten on a laptop.",

    "docs/meetings/2026-10-13.md": "# Kickoff",

    "docs/research/Pricing model.md": null,

  });

  const read = await syncSpace(db, repo.forge, space.id);

  expect(read.pulled).toBe(3);

  expect(byTitle("Ideas").body).toBe("Rewritten on a laptop.");

  expect(byTitle("Ideas").author_name).toBe("the repository");

  expect(byTitle("2026-10-13").path).toBe("docs/meetings/2026-10-13.md");

  expect(notes().some((n) => n.title === "Pricing model")).toBe(false);

  expect(repo.commits.length).toBe(2);

});

test("edited in both places: ours is committed, theirs is kept beside it — nothing is lost", async () => {

  const repo = fakeForge({ "Plan.md": "v1" });

  const space = must(createSpace(db, ben, { name: "Both", repo: "ben/both" }));

  await syncSpace(db, repo.forge, space.id);

  const plan = must(listNotes(db, ben, { space: space.id }))[0]!;

  must(updateNote(db, ben, { id: plan.id, body: "ours" }));

  repo.push({ "Plan.md": "theirs" });

  const r = await syncSpace(db, repo.forge, space.id);

  expect(r.copies).toBe(1);

  expect(repo.tree.get("Plan.md")).toBe("ours");

  expect(repo.tree.get("Plan (repo copy).md")).toBe("theirs");

  const titles = must(listNotes(db, ben, { space: space.id })).map((n) => n.title).sort();

  expect(titles).toEqual(["Plan", "Plan (repo copy)"]);

});

test("a repository that can't be read is said, and the space remembers why", async () => {

  const space = must(createSpace(db, ben, { name: "Broken", repo: "ben/gone" }));

  const broken: Forge = {

    ...fakeForge().forge,

    head: async () => {

      throw new Error("No repository ben/gone — or the token can't see it.");

    },

  };

  await expect(syncSpace(db, broken, space.id)).rejects.toThrow("No repository");

  const row = mySpaces(db, ben).find((s) => s.id === space.id)!;

  expect(row.sync_error).toContain("No repository");

});

test("properties at the top of a note read as properties, not as a rule and a paragraph", () => {

  const html = md.render("---\ntitle: Plan\ntags:\n  - a\n  - b\n---\n# Body", {});

  expect(html).toContain('<dl class="properties">');

  expect(html).toContain("<dd>a, b</dd>");

  expect(html).not.toContain("<hr>");

  expect(md.tags("---\ntags: x, y\n---\n#z")).toEqual(["x", "y", "z"]);

  expect(md.render("[[Missing]] #t", { base: "/s/3" })).toContain('href="/s/3/open?title=Missing"');

});