Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

27.5 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { globSync, mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { Hono } from "hono";
import { AppError } from "./app-error.ts";
import { apiError } from "./http-errors.ts";
import { listMemos } from "./memo-list-service.ts";
import { registerMemoRoutes } from "./memo-routes.ts";
import {
  createMemoRecord,
  deleteMemoRecord,
  deleteMemosRecord,
  emptyTrashMemosRecord,
  getMemoDetail,
  restoreMemoRecord,
  restoreMemosRecord,
} from "./memo-service.ts";
import { createAttachmentResource, createImageResource } from "./resource-service.ts";
import { createSelfHostedStorageAdapter } from "./self-hosted-storage-adapter.ts";

const WORKSPACE_ID = "ws_default";
const OTHER_WORKSPACE_ID = "ws_other";
const userAuth = {
  kind: "user", actorType: "user", actorId: "usr_owner", username: "admin", displayName: "Admin",
  scopes: [], workspaceId: WORKSPACE_ID, role: "owner",
};
const agentAuth = (scopes) => ({
  kind: "agent", actorType: "agent", actorId: "tok_agent", username: "agent", displayName: null,
  scopes, workspaceId: WORKSPACE_ID, role: "member",
});
const actor = { actorType: "user", actorId: "usr_owner" };
const PNG = Buffer.from(
  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=",
  "base64",
);
const notImplemented = async () => { throw new Error("not used"); };

const cleanups = [];
afterEach(() => cleanups.splice(0).forEach((cleanup) => cleanup()));

const installation = () => {
  const sqlite = new Database(":memory:");
  for (const file of globSync("migrations/*.sql").sort()) sqlite.exec(readFileSync(file, "utf8"));
  // The self-hosted server enables this on every connection.
  sqlite.exec("PRAGMA foreign_keys = ON");
  sqlite.exec(`
    INSERT INTO workspaces (id, name, is_personal) VALUES ('${OTHER_WORKSPACE_ID}', 'Other', 1);
    INSERT INTO notebooks (id, workspace_id, parent_id, name, slug, sort_order)
      VALUES ('nb_trips', '${WORKSPACE_ID}', NULL, 'Trips', 'trips', 7),
             ('nb_other', '${OTHER_WORKSPACE_ID}', NULL, 'Theirs', 'inbox', 0);
  `);
  const resourcesDirectory = mkdtempSync(join(tmpdir(), "edgeever-trash-"));
  cleanups.push(() => {
    sqlite.close();
    rmSync(resourcesDirectory, { recursive: true, force: true });
  });
  const storage = createSelfHostedStorageAdapter(sqlite, resourcesDirectory);
  const app = new Hono();
  let auth = userAuth;
  app.use("/api/v1/*", async (context, next) => {
    context.set("auth", auth);
    await next();
  });
  // Mirrors the application's error handler in index.ts.
  app.onError((error, context) => {
    if (error instanceof AppError) return apiError(context, error.code, error.message, error.status);
    throw error;
  });
  registerMemoRoutes(app, {
    clampNumber: (value, min, max) => Math.min(Math.max(value, min), max),
    createImageResource,
    createMemo: createMemoRecord,
    createMemoEditSession: notImplemented,
    deleteMemo: deleteMemoRecord,
    deleteMemos: deleteMemosRecord,
    emptyTrash: emptyTrashMemosRecord,
    getMemoDetail,
    listMemoRevisions: notImplemented,
    listMemos,
    mergeMemos: notImplemented,
    moveMemos: notImplemented,
    restoreMemo: restoreMemoRecord,
    restoreMemoRevision: notImplemented,
    updateMemo: notImplemented,
  });
  const request = async (path, init = {}) => {
    const response = await app.request(path, init, { storage });
    const text = await response.text();
    return { status: response.status, body: text ? JSON.parse(text) : null };
  };
  const postJson = (path, body) => request(path, {
    method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body),
  });
  const storedFiles = () => readdirSync(resourcesDirectory, { recursive: true, withFileTypes: true })
    .filter((entry) => entry.isFile())
    .map((entry) => join(entry.parentPath ?? entry.path, entry.name).slice(resourcesDirectory.length + 1))
    .sort();
  const readObject = async (objectKey) => {
    const object = await storage.resources.get(objectKey);
    return object ? Buffer.from(await new Response(object.body).arrayBuffer()) : null;
  };
  const contextFor = (workspaceId) => ({
    env: { storage },
    get: (key) => (key === "auth" ? { ...userAuth, workspaceId } : undefined),
  });
  return {
    sqlite, storage, env: { storage }, contextFor, request, postJson, storedFiles, readObject,
    setAuth: (next) => { auth = next; },
  };
};

// A note with tags, an image, an attachment, a revision and a public share.
const createNote = async (target, {
  workspaceId = WORKSPACE_ID, notebookId = "nb_trips", title = "Trip plan", body = "Pack the tent", tags = ["travel"],
} = {}) => {
  const memo = await createMemoRecord(target.storage.db, workspaceId, {
    notebookId, title, contentMarkdown: body, tags,
  }, actor, "admin");
  const context = target.contextFor(workspaceId);
  const image = await createImageResource(context, {
    memoId: memo.id, filename: "map.png", mimeType: "image/png", bytes: PNG, actor, source: "upload",
  });
  const attachment = await createAttachmentResource(context, {
    memoId: memo.id, filename: `${title}.txt`, mimeType: "text/plain", bytes: new TextEncoder().encode(`${title} file`), actor,
  });
  target.sqlite.query(
    `INSERT INTO memo_revisions (id, memo_id, revision, title, content_json, content_markdown, content_hash, created_by, tags_json, content_text)
     VALUES (?, ?, 1, ?, '{}', 'Old draft', 'hash', 'admin', '[]', 'Old draft')`,
  ).run(`rev_${memo.id}`, memo.id, title);
  target.sqlite.query("INSERT INTO memo_shares (id, memo_id, workspace_id, token) VALUES (?, ?, ?, ?)")
    .run(`share_${memo.id}`, memo.id, workspaceId, `token_${memo.id}`);
  const objectKeys = [image.id, attachment.id].map((id) =>
    target.sqlite.query("SELECT object_key FROM resources WHERE id = ?").get(id).object_key);
  return { memo, image, attachment, objectKeys, imageBytes: await target.readObject(objectKeys[0]) };
};

const countRows = (sqlite, table, memoId) =>
  sqlite.query(`SELECT COUNT(*) AS count FROM ${table} WHERE memo_id = ?`).get(memoId).count;

const memoRowCounts = (sqlite, memoId) => ({
  memos: sqlite.query("SELECT COUNT(*) AS count FROM memos WHERE id = ?").get(memoId).count,
  memo_contents: countRows(sqlite, "memo_contents", memoId),
  memo_revisions: countRows(sqlite, "memo_revisions", memoId),
  resources: countRows(sqlite, "resources", memoId),
  memo_tags: countRows(sqlite, "memo_tags", memoId),
  memo_search_documents: countRows(sqlite, "memo_search_documents", memoId),
  memo_shares: countRows(sqlite, "memo_shares", memoId),
});

const auditEvents = (sqlite, action) => sqlite.query(
  "SELECT actor_type, actor_id, entity_type, entity_id, metadata_json FROM audit_events WHERE action = ? ORDER BY entity_id",
).all(action).map((row) => ({ ...row, metadata: JSON.parse(row.metadata_json), metadata_json: undefined }));

const listedIds = async (target, query = "") => {
  const response = await target.request(`/api/v1/memos${query}`);
  expect(response.status).toBe(200);
  return response.body.memos.map((memo) => memo.id).sort();
};

const memoState = (sqlite, memoId) =>
  sqlite.query("SELECT notebook_id, is_deleted, deleted_at FROM memos WHERE id = ?").get(memoId);

const trash = (target, memoId) => target.request(`/api/v1/memos/${memoId}`, { method: "DELETE" });

describe("moving notes to trash", () => {
  test("keeps content, files and revisions but removes the note from lists, search and sharing", async () => {
    const target = installation();
    const note = await createNote(target);
    const filesBefore = target.storedFiles();
    expect(filesBefore).toHaveLength(2);
    expect(await listedIds(target, "?q=tent")).toEqual([note.memo.id]);

    const response = await trash(target, note.memo.id);

    expect(response).toEqual({ status: 200, body: { ok: true } });
    expect(memoState(target.sqlite, note.memo.id)).toMatchObject({ is_deleted: 1, deleted_at: expect.any(String) });
    expect(memoRowCounts(target.sqlite, note.memo.id)).toEqual({
      memos: 1, memo_contents: 1, memo_revisions: 1, resources: 2, memo_tags: 1,
      memo_search_documents: 0, memo_shares: 0,
    });
    expect(target.sqlite.query("SELECT DISTINCT is_deleted FROM resources WHERE memo_id = ?").all(note.memo.id))
      .toEqual([{ is_deleted: 1 }]);
    expect(target.storedFiles()).toEqual(filesBefore);
    expect(await target.readObject(note.objectKeys[1])).toEqual(Buffer.from("Trip plan file"));

    expect(await listedIds(target)).not.toContain(note.memo.id);
    expect(await listedIds(target, "?q=tent")).toEqual([]);
    expect(await listedIds(target, "?trash=1")).toEqual([note.memo.id]);
    expect((await target.request(`/api/v1/memos/${note.memo.id}`)).status).toBe(404);
    const inTrash = await target.request(`/api/v1/memos/${note.memo.id}?includeDeleted=1`);
    expect(inTrash.body.memo).toMatchObject({ isDeleted: true, contentMarkdown: "Pack the tent", tags: ["travel"] });

    expect(auditEvents(target.sqlite, "memo.delete")).toEqual([{
      actor_type: "user", actor_id: "usr_owner", entity_type: "memo", entity_id: note.memo.id, metadata: {},
    }]);
  });

  test("treats a note that is already in trash or does not exist as a no-op", async () => {
    const target = installation();
    const note = await createNote(target);
    await trash(target, note.memo.id);
    const before = memoState(target.sqlite, note.memo.id);

    expect(await trash(target, note.memo.id)).toEqual({ status: 200, body: { ok: true } });
    expect(await trash(target, "memo_missing")).toEqual({ status: 200, body: { ok: true } });

    expect(memoState(target.sqlite, note.memo.id)).toEqual(before);
    expect(auditEvents(target.sqlite, "memo.delete")).toHaveLength(1);
  });

  test("does not touch a note from another workspace", async () => {
    const target = installation();
    const theirs = await createNote(target, { workspaceId: OTHER_WORKSPACE_ID, notebookId: "nb_other" });

    expect(await trash(target, theirs.memo.id)).toEqual({ status: 200, body: { ok: true } });

    expect(memoState(target.sqlite, theirs.memo.id).is_deleted).toBe(0);
    expect(memoRowCounts(target.sqlite, theirs.memo.id)).toMatchObject({ memo_search_documents: 1, memo_shares: 1 });
    expect(auditEvents(target.sqlite, "memo.delete")).toEqual([]);
  });
});

describe("restoring notes from trash", () => {
  test("brings the note back with its content, tags, notebook and files", async () => {
    const target = installation();
    const note = await createNote(target);
    await trash(target, note.memo.id);

    const response = await target.request(`/api/v1/memos/${note.memo.id}/restore`, { method: "POST" });

    expect(response.status).toBe(200);
    expect(response.body.memo).toMatchObject({
      id: note.memo.id, notebookId: "nb_trips", title: "Trip plan", contentMarkdown: "Pack the tent",
      tags: ["travel"], isDeleted: false, deletedAt: null,
    });
    expect(memoState(target.sqlite, note.memo.id)).toEqual({ notebook_id: "nb_trips", is_deleted: 0, deleted_at: null });
    expect(target.sqlite.query("SELECT DISTINCT is_deleted, deleted_at FROM resources WHERE memo_id = ?").all(note.memo.id))
      .toEqual([{ is_deleted: 0, deleted_at: null }]);
    expect(await target.readObject(note.objectKeys[0])).toEqual(note.imageBytes);
    expect(await target.readObject(note.objectKeys[1])).toEqual(Buffer.from("Trip plan file"));
    expect(memoRowCounts(target.sqlite, note.memo.id)).toMatchObject({ memo_revisions: 1, memo_search_documents: 1 });
    expect(await listedIds(target, "?q=tent")).toEqual([note.memo.id]);
    expect(await listedIds(target, "?tag=travel")).toEqual([note.memo.id]);
    expect(await listedIds(target, "?trash=1")).toEqual([]);
    // The public share link is not recreated.
    expect(countRows(target.sqlite, "memo_shares", note.memo.id)).toBe(0);
    expect(auditEvents(target.sqlite, "memo.restore")).toEqual([{
      actor_type: "user", actor_id: "usr_owner", entity_type: "memo", entity_id: note.memo.id,
      metadata: { fromNotebookId: "nb_trips", toNotebookId: "nb_trips" },
    }]);
  });

  test("restores into the inbox when the original notebook was deleted meanwhile", async () => {
    const target = installation();
    const note = await createNote(target);
    await trash(target, note.memo.id);
    target.sqlite.query("UPDATE notebooks SET is_deleted = 1, deleted_at = '2026-03-01T00:00:00.000Z' WHERE id = 'nb_trips'").run();

    const response = await target.request(`/api/v1/memos/${note.memo.id}/restore`, { method: "POST" });

    expect(response.status).toBe(200);
    expect(response.body.memo).toMatchObject({ notebookId: "nb_inbox", contentMarkdown: "Pack the tent", tags: ["travel"] });
    expect(auditEvents(target.sqlite, "memo.restore")[0].metadata)
      .toEqual({ fromNotebookId: "nb_trips", toNotebookId: "nb_inbox" });
  });

  test("refuses to restore when both the original notebook and the inbox are gone", async () => {
    const target = installation();
    const note = await createNote(target);
    await trash(target, note.memo.id);
    target.sqlite.query("UPDATE notebooks SET is_deleted = 1 WHERE workspace_id = ?").run(WORKSPACE_ID);

    const response = await target.request(`/api/v1/memos/${note.memo.id}/restore`, { method: "POST" });

    expect(response.status).toBe(409);
    expect(response.body.error.code).toBe("restore_notebook_missing");
    expect(memoState(target.sqlite, note.memo.id)).toMatchObject({ notebook_id: "nb_trips", is_deleted: 1 });
    expect(auditEvents(target.sqlite, "memo.restore")).toEqual([]);
  });

  test("returns 404 for a note that is active, missing or in another workspace's trash", async () => {
    const target = installation();
    const active = await createNote(target);
    const theirs = await createNote(target, { workspaceId: OTHER_WORKSPACE_ID, notebookId: "nb_other" });
    await deleteMemoRecord(target.env, OTHER_WORKSPACE_ID, theirs.memo.id, false, actor);

    for (const memoId of [active.memo.id, "memo_missing", theirs.memo.id]) {
      const response = await target.request(`/api/v1/memos/${memoId}/restore`, { method: "POST" });
      expect(response.status).toBe(404);
      expect(response.body.error.code).toBe("not_found");
    }
    expect(memoState(target.sqlite, theirs.memo.id).is_deleted).toBe(1);
    expect(auditEvents(target.sqlite, "memo.restore")).toEqual([]);
  });

  test("restores several notes at once, each into its own or the fallback notebook", async () => {
    const target = installation();
    const kept = await createNote(target, { notebookId: "nb_projects", title: "Kept" });
    const orphan = await createNote(target, { title: "Orphan" });
    await deleteMemosRecord(target.env, WORKSPACE_ID, [kept.memo.id, orphan.memo.id], false, actor);
    target.sqlite.query("UPDATE notebooks SET is_deleted = 1 WHERE id = 'nb_trips'").run();

    expect(await restoreMemosRecord(target.storage.db, WORKSPACE_ID, [kept.memo.id, orphan.memo.id, kept.memo.id], actor))
      .toBe(2);

    expect(memoState(target.sqlite, kept.memo.id)).toEqual({ notebook_id: "nb_projects", is_deleted: 0, deleted_at: null });
    expect(memoState(target.sqlite, orphan.memo.id)).toEqual({ notebook_id: "nb_inbox", is_deleted: 0, deleted_at: null });
    expect(auditEvents(target.sqlite, "memo.restore")).toHaveLength(2);
    expect(await restoreMemosRecord(target.storage.db, WORKSPACE_ID, [], actor)).toBe(0);
  });

  test("restores nothing when any id is missing, active or from another workspace", async () => {
    const target = installation();
    const trashed = await createNote(target, { title: "Trashed" });
    const active = await createNote(target, { title: "Active" });
    const theirs = await createNote(target, { workspaceId: OTHER_WORKSPACE_ID, notebookId: "nb_other" });
    await deleteMemoRecord(target.env, WORKSPACE_ID, trashed.memo.id, false, actor);
    await deleteMemoRecord(target.env, OTHER_WORKSPACE_ID, theirs.memo.id, false, actor);

    for (const extra of ["memo_missing", active.memo.id, theirs.memo.id]) {
      await expect(restoreMemosRecord(target.storage.db, WORKSPACE_ID, [trashed.memo.id, extra], actor))
        .rejects.toMatchObject({ code: "missing_memos", status: 400 });
    }

    expect(memoState(target.sqlite, trashed.memo.id).is_deleted).toBe(1);
    expect(memoState(target.sqlite, theirs.memo.id).is_deleted).toBe(1);
    expect(auditEvents(target.sqlite, "memo.restore")).toEqual([]);
  });
});

describe("permanently deleting notes", () => {
  test("removes a trashed note's rows and stored files and leaves other notes alone", async () => {
    const target = installation();
    const doomed = await createNote(target, { title: "Doomed" });
    const survivor = await createNote(target, { title: "Survivor" });
    // A file that was moved into the survivor during a merge still points back at the doomed note.
    target.sqlite.query("UPDATE resources SET original_memo_id = ? WHERE id = ?").run(doomed.memo.id, survivor.attachment.id);
    await trash(target, doomed.memo.id);

    const response = await target.request(`/api/v1/memos/${doomed.memo.id}?permanent=1`, { method: "DELETE" });

    expect(response).toEqual({ status: 200, body: { ok: true } });
    expect(memoRowCounts(target.sqlite, doomed.memo.id)).toEqual({
      memos: 0, memo_contents: 0, memo_revisions: 0, resources: 0, memo_tags: 0,
      memo_search_documents: 0, memo_shares: 0,
    });
    expect(target.storedFiles()).toEqual([...survivor.objectKeys].sort());
    expect(await target.readObject(doomed.objectKeys[1])).toBeNull();
    expect(await target.readObject(survivor.objectKeys[1])).toEqual(Buffer.from("Survivor file"));
    expect(memoRowCounts(target.sqlite, survivor.memo.id)).toEqual({
      memos: 1, memo_contents: 1, memo_revisions: 1, resources: 2, memo_tags: 1,
      memo_search_documents: 1, memo_shares: 1,
    });
    expect(target.sqlite.query("SELECT original_memo_id FROM resources WHERE id = ?").get(survivor.attachment.id))
      .toEqual({ original_memo_id: null });
    expect(auditEvents(target.sqlite, "memo.delete_permanent")).toEqual([{
      actor_type: "user", actor_id: "usr_owner", entity_type: "memo", entity_id: doomed.memo.id, metadata: {},
    }]);
  });

  test("only deletes notes that are in the caller's trash", async () => {
    const target = installation();
    const active = await createNote(target);
    const theirs = await createNote(target, { workspaceId: OTHER_WORKSPACE_ID, notebookId: "nb_other" });
    await deleteMemoRecord(target.env, OTHER_WORKSPACE_ID, theirs.memo.id, false, actor);
    const filesBefore = target.storedFiles();

    for (const memoId of [active.memo.id, "memo_missing", theirs.memo.id]) {
      const response = await target.request(`/api/v1/memos/${memoId}?permanent=1`, { method: "DELETE" });
      expect(response.status).toBe(404);
      expect(response.body.error.code).toBe("not_found");
    }

    expect(target.storedFiles()).toEqual(filesBefore);
    expect(memoRowCounts(target.sqlite, active.memo.id).memos).toBe(1);
    expect(memoRowCounts(target.sqlite, theirs.memo.id).memos).toBe(1);
    expect(auditEvents(target.sqlite, "memo.delete_permanent")).toEqual([]);
  });
});

describe("batch deletion", () => {
  test("moves several notes to trash and counts duplicates once", async () => {
    const target = installation();
    const first = await createNote(target, { title: "First" });
    const second = await createNote(target, { title: "Second" });

    const response = await target.postJson("/api/v1/memos/batch/delete", {
      memoIds: [first.memo.id, second.memo.id, first.memo.id],
    });

    expect(response).toEqual({ status: 200, body: { ok: true, deleted: 2 } });
    expect(await listedIds(target, "?trash=1")).toEqual([first.memo.id, second.memo.id].sort());
    expect(target.storedFiles()).toHaveLength(4);
    expect(auditEvents(target.sqlite, "memo.delete").map((event) => event.entity_id))
      .toEqual([first.memo.id, second.memo.id].sort());
  });

  test("changes nothing when any id is missing, in the wrong state or from another workspace", async () => {
    const target = installation();
    const active = await createNote(target, { title: "Active" });
    const trashed = await createNote(target, { title: "Trashed" });
    const theirs = await createNote(target, { workspaceId: OTHER_WORKSPACE_ID, notebookId: "nb_other" });
    await deleteMemoRecord(target.env, WORKSPACE_ID, trashed.memo.id, false, actor);
    const filesBefore = target.storedFiles();
    const auditBefore = target.sqlite.query("SELECT COUNT(*) AS count FROM audit_events").get().count;

    const attempts = [
      { memoIds: [active.memo.id, "memo_missing"] },
      { memoIds: [active.memo.id, trashed.memo.id] },
      { memoIds: [active.memo.id, theirs.memo.id] },
      { memoIds: [trashed.memo.id, active.memo.id], permanent: true },
      { memoIds: [trashed.memo.id, theirs.memo.id], permanent: true },
    ];
    for (const body of attempts) {
      const response = await target.postJson("/api/v1/memos/batch/delete", body);
      expect(response.status).toBe(400);
      expect(response.body.error.code).toBe("missing_memos");
    }

    expect(memoState(target.sqlite, active.memo.id).is_deleted).toBe(0);
    expect(memoState(target.sqlite, trashed.memo.id).is_deleted).toBe(1);
    expect(memoState(target.sqlite, theirs.memo.id).is_deleted).toBe(0);
    expect(target.storedFiles()).toEqual(filesBefore);
    expect(target.sqlite.query("SELECT COUNT(*) AS count FROM audit_events").get().count).toBe(auditBefore);
  });

  test("permanently deletes several trashed notes with their files", async () => {
    const target = installation();
    const first = await createNote(target, { title: "First" });
    const second = await createNote(target, { title: "Second" });
    const survivor = await createNote(target, { title: "Survivor" });
    await deleteMemosRecord(target.env, WORKSPACE_ID, [first.memo.id, second.memo.id], false, actor);

    const response = await target.postJson("/api/v1/memos/batch/delete", {
      memoIds: [first.memo.id, second.memo.id], permanent: true,
    });

    expect(response).toEqual({ status: 200, body: { ok: true, deleted: 2 } });
    expect(target.storedFiles()).toEqual([...survivor.objectKeys].sort());
    for (const memoId of [first.memo.id, second.memo.id]) {
      expect(Object.values(memoRowCounts(target.sqlite, memoId)).every((count) => count === 0)).toBe(true);
    }
    expect(auditEvents(target.sqlite, "memo.delete_permanent")).toHaveLength(2);
  });

  test("rejects an empty or malformed id list before touching anything", async () => {
    const target = installation();
    for (const body of [{ memoIds: [] }, { memoIds: [""] }, {}]) {
      expect((await target.postJson("/api/v1/memos/batch/delete", body)).status).toBe(400);
    }
    expect(await deleteMemosRecord(target.env, WORKSPACE_ID, [], true, actor)).toBe(0);
  });
});

describe("emptying trash", () => {
  test("permanently deletes only the caller's trashed notes and their files", async () => {
    const target = installation();
    const first = await createNote(target, { title: "First" });
    const second = await createNote(target, { title: "Second" });
    const active = await createNote(target, { title: "Active" });
    const theirs = await createNote(target, { workspaceId: OTHER_WORKSPACE_ID, notebookId: "nb_other", title: "Theirs" });
    target.sqlite.query("UPDATE resources SET original_memo_id = ? WHERE id = ?").run(first.memo.id, active.attachment.id);
    await deleteMemosRecord(target.env, WORKSPACE_ID, [first.memo.id, second.memo.id], false, actor);
    await deleteMemoRecord(target.env, OTHER_WORKSPACE_ID, theirs.memo.id, false, actor);

    const response = await target.request("/api/v1/memos/trash/empty", { method: "DELETE" });

    expect(response).toEqual({ status: 200, body: { ok: true, deleted: 2 } });
    for (const memoId of [first.memo.id, second.memo.id]) {
      expect(Object.values(memoRowCounts(target.sqlite, memoId)).every((count) => count === 0)).toBe(true);
    }
    expect(target.storedFiles()).toEqual([...active.objectKeys, ...theirs.objectKeys].sort());
    expect(memoState(target.sqlite, active.memo.id).is_deleted).toBe(0);
    expect(memoRowCounts(target.sqlite, active.memo.id).resources).toBe(2);
    expect(target.sqlite.query("SELECT original_memo_id FROM resources WHERE id = ?").get(active.attachment.id))
      .toEqual({ original_memo_id: null });
    expect(memoState(target.sqlite, theirs.memo.id).is_deleted).toBe(1);
    expect(memoRowCounts(target.sqlite, theirs.memo.id)).toMatchObject({ memos: 1, memo_contents: 1, resources: 2 });
    expect(auditEvents(target.sqlite, "memo.trash_empty")).toEqual([{
      actor_type: "user", actor_id: "usr_owner", entity_type: "trash", entity_id: "memos", metadata: { deleted: 2 },
    }]);
  });

  test("does nothing and writes no audit event when the trash is already empty", async () => {
    const target = installation();
    const active = await createNote(target);

    expect(await target.request("/api/v1/memos/trash/empty", { method: "DELETE" }))
      .toEqual({ status: 200, body: { ok: true, deleted: 0 } });

    expect(target.storedFiles()).toEqual([...active.objectKeys].sort());
    expect(auditEvents(target.sqlite, "memo.trash_empty")).toEqual([]);
  });
});

describe("trash route permissions", () => {
  const routes = (memoId) => [
    ["DELETE", `/api/v1/memos/${memoId}`],
    ["DELETE", `/api/v1/memos/${memoId}?permanent=1`],
    ["POST", `/api/v1/memos/${memoId}/restore`],
    ["POST", "/api/v1/memos/batch/delete", { memoIds: [memoId] }],
    ["DELETE", "/api/v1/memos/trash/empty"],
  ];
  const send = (target, [method, path, body]) => target.request(path, body
    ? { method, headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }
    : { method });

  test("requires write:memos for tokens and changes nothing without it", async () => {
    const target = installation();
    const note = await createNote(target);
    await deleteMemoRecord(target.env, WORKSPACE_ID, note.memo.id, false, actor);
    target.setAuth(agentAuth(["read:memos"]));

    for (const route of routes(note.memo.id)) {
      const response = await send(target, route);
      expect(response.status).toBe(403);
      expect(response.body.error.code).toBe("forbidden");
    }
    expect(memoState(target.sqlite, note.memo.id).is_deleted).toBe(1);
    expect(target.storedFiles()).toHaveLength(2);
  });

  test("rejects unauthenticated requests", async () => {
    const target = installation();
    target.setAuth(undefined);
    for (const route of routes("memo_any")) {
      expect((await send(target, route)).status).toBe(401);
    }
  });

  test("lets a token with write:memos trash, restore and purge notes, recorded as the agent", async () => {
    const target = installation();
    const note = await createNote(target);
    target.setAuth(agentAuth(["write:memos"]));

    expect((await trash(target, note.memo.id)).status).toBe(200);
    expect((await target.request(`/api/v1/memos/${note.memo.id}/restore`, { method: "POST" })).status).toBe(200);
    expect((await trash(target, note.memo.id)).status).toBe(200);
    expect(await target.request("/api/v1/memos/trash/empty", { method: "DELETE" }))
      .toEqual({ status: 200, body: { ok: true, deleted: 1 } });

    expect(target.sqlite.query(
      "SELECT action, actor_type, actor_id FROM audit_events WHERE actor_type = 'agent' ORDER BY rowid",
    ).all()).toEqual([
      { action: "memo.delete", actor_type: "agent", actor_id: "tok_agent" },
      { action: "memo.restore", actor_type: "agent", actor_id: "tok_agent" },
      { action: "memo.delete", actor_type: "agent", actor_id: "tok_agent" },
      { action: "memo.trash_empty", actor_type: "agent", actor_id: "tok_agent" },
    ]);
  });
});