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,

  BODY_MAX,

  cleanTitle,

  deleteNote,

  findNote,

  getNote,

  listNotes,

  openOrCreate,

  searchNotes,

  today,

  updateNote,

} from "./actions.ts";

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

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

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

const anon: Who = { role: "anon" };

const alice: Who = { role: "user", id: "u1", name: "alice" };

const bob: Who = { role: "user", id: "u2", name: "bob" };

const root: Who = { role: "admin", id: "u0", name: "root" };

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

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

  return r.value;

};

test("a vault is its author's: nobody else lists or reads it, admins included", () => {

  const refused = addNote(db, anon, { title: "x" });

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

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

  const mine = must(addNote(db, alice, { title: "  Secret   plans ", body: "the plan" }));

  expect(mine.title).toBe("Secret plans");

  expect(mine.author_name).toBe("alice");

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

  expect(must(listNotes(db, bob))).toEqual([]);

  expect(must(listNotes(db, root))).toEqual([]);

  for (const who of [bob, root]) {

    const read = getNote(db, who, { id: mine.id });

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

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

    expect(updateNote(db, who, { id: mine.id, body: "mine now" }).ok).toBe(false);

    expect(deleteNote(db, who, { id: mine.id }).ok).toBe(false);

  }

  const listed = listNotes(db, anon);

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

  // Two people may each have a note of the same name.

  expect(addNote(db, bob, { title: "secret plans" }).ok).toBe(true);

});

test("titles are unique in a vault, any case; blank means the next Untitled", () => {

  expect(must(addNote(db, alice, {})).title).toBe("Untitled");

  expect(must(addNote(db, alice, { title: "" })).title).toBe("Untitled 2");

  const dup = addNote(db, alice, { title: "SECRET PLANS" });

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

  if (!dup.ok) expect(dup.error).toBe("invalid");

  for (const bad of ["a [b]", "x|y", "a#b", "^", "x".repeat(201), "   "])

    expect([bad, cleanTitle(bad).ok]).toEqual([bad, false]);

  expect(cleanTitle("2026-10-02").ok).toBe(true);

  const big = addNote(db, alice, { title: "big", body: "x".repeat(BODY_MAX + 1) });

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

});

test("renaming a note carries every link to it, keeping aliases and headings", () => {

  const target = must(addNote(db, alice, { title: "Garden" }));

  const a = must(addNote(db, alice, { title: "Links A", body: "see [[Garden]] and [[garden#Beds|the beds]]" }));

  const b = must(addNote(db, alice, { title: "Links B", body: "no link, just garden" }));

  // Bob's note links a Garden of his own: a rename in alice's vault leaves it be.

  const bobs = must(addNote(db, bob, { title: "Bob's", body: "[[Garden]]" }));

  const renamed = must(updateNote(db, alice, { id: target.id, title: "Allotment" }));

  expect(renamed.title).toBe("Allotment");

  expect(renamed.relinked).toBe(1);

  expect(must(getNote(db, alice, { id: a.id })).body).toBe(

    "see [[Allotment]] and [[Allotment#Beds|the beds]]",

  );

  expect(must(getNote(db, alice, { id: b.id })).body).toBe("no link, just garden");

  expect(must(getNote(db, bob, { id: bobs.id })).body).toBe("[[Garden]]");

  // A rename onto a title in use is refused, and changes nothing.

  const clash = updateNote(db, alice, { id: target.id, title: "links a" });

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

  expect(must(getNote(db, alice, { id: target.id })).title).toBe("Allotment");

});

test("pinning floats a note to the top", () => {

  const pinned = must(addNote(db, alice, { title: "Pin me" }));

  must(addNote(db, alice, { title: "Newer" }));

  must(updateNote(db, alice, { id: pinned.id, pinned: true }));

  expect(must(listNotes(db, alice))[0]?.id).toBe(pinned.id);

  must(updateNote(db, alice, { id: pinned.id, pinned: false }));

  expect(must(listNotes(db, alice))[0]?.id).not.toBe(pinned.id);

});

test("following a link opens the note, or makes it", () => {

  const made = must(openOrCreate(db, alice, { title: "Reading list" }));

  expect(made.created).toBe(true);

  const again = must(openOrCreate(db, alice, { title: "reading LIST" }));

  expect(again.created).toBe(false);

  expect(again.id).toBe(made.id);

  expect(must(findNote(db, alice, { title: "Reading list" })).id).toBe(made.id);

  expect(findNote(db, bob, { title: "Reading list" }).ok).toBe(false);

});

test("search finds words, phrases and tags, in your vault only", () => {

  must(addNote(db, alice, { title: "Recipes", body: "Bread with #cooking/baking\nsour dough starter" }));

  must(addNote(db, alice, { title: "Groceries", body: "flour, #cooking" }));

  must(addNote(db, bob, { title: "Bob recipes", body: "#cooking" }));

  const titles = (q: string) => must(searchNotes(db, alice, { q })).map((h) => h.title);

  expect(titles("#cooking").sort()).toEqual(["Groceries", "Recipes"]);

  expect(titles("tag:cooking/baking")).toEqual(["Recipes"]);

  expect(titles('"sour dough"')).toEqual(["Recipes"]);

  expect(titles("dough flour")).toEqual([]);

  expect(titles("recipes")).toEqual(["Recipes"]);

  expect(must(searchNotes(db, alice, { q: "sour" }))[0]?.snippet).toContain("sour dough");

  expect(searchNotes(db, anon, { q: "cooking" }).ok).toBe(false);

});

test("only the author removes a note", () => {

  const mine = must(addNote(db, alice, { title: "Ephemeral" }));

  const byAnon = deleteNote(db, anon, { id: mine.id });

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

  if (!byAnon.ok) expect(byAnon.error).toBe("signin_required");

  expect(deleteNote(db, alice, { id: mine.id }).ok).toBe(true);

  const gone = deleteNote(db, alice, { id: mine.id });

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

  if (!gone.ok) expect(gone.error).toBe("not_found");

  const odd = deleteNote(db, alice, { id: 1.5 });

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

  if (!odd.ok) expect(odd.error).toBe("invalid");

});

test("today is the date where you are", () => {

  const at = new Date("2026-10-02T02:00:00Z");

  expect(today(0, at)).toBe("2026-10-02");

  // Chicago in October is UTC-5: getTimezoneOffset() says 300.

  expect(today(300, at)).toBe("2026-10-01");

  expect(today(-600, at)).toBe("2026-10-02");

});