Skip to content

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

test(api): cover note trash, user and session management, and object storage settings (#572)

Dariusz Koryto41bce7a1266a
diff --git a/apps/api/src/auth-routes.test.mjs b/apps/api/src/auth-routes.test.mjs
index 55f49259..eccd6084 100644
--- a/apps/api/src/auth-routes.test.mjs
+++ b/apps/api/src/auth-routes.test.mjs
@@ -1,10 +1,21 @@
import { Database } from "bun:sqlite";
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
import { globSync, readFileSync } from "node:fs";
import { Hono } from "hono";
import { hashPassword, verifyPassword } from "./auth-crypto.ts";
import { registerAuthRoutes } from "./auth-routes.ts";
-import { authenticateRequest } from "./auth-service.ts";
+import {
+ authenticateRequest,
+ authenticateSession,
+ createSession,
+ getBearerToken,
+ getInstanceAuthMode,
+ getLoginAttemptKeys,
+ revokeSession,
+ setSessionCookie,
+ tooManyLoginAttempts,
+ verifyLogin,
+} from "./auth-service.ts";
import { sha256 } from "./hash-utils.ts";
import { createSelfHostedStorageAdapter } from "./self-hosted-storage-adapter.ts";
import { ensureUserWorkspace } from "./workspace-provisioning.ts";
@@ -236,3 +247,304 @@ describe("first sign-in seed localization", () => {
.toEqual({ status: 200, inbox: "等待分类", pending: 0 });
});
});
+
+describe("login session management with a real database", () => {
+ const instances = [];
+ afterEach(() => {
+ for (const sqlite of instances.splice(0)) sqlite.close();
+ });
+
+ const DEVICE_A = "device-a-0000000001";
+ const DEVICE_B = "device-b-0000000002";
+ const DEVICE_C = "device-c-0000000003";
+ const DAY_MS = 86_400_000;
+
+ const createInstance = async () => {
+ const sqlite = new Database(":memory:");
+ instances.push(sqlite);
+ for (const path of globSync("migrations/*.sql").sort()) sqlite.exec(readFileSync(path, "utf8"));
+ const insertUser = sqlite.query("INSERT INTO users (id, username, password_hash, display_name) VALUES (?, ?, ?, ?)");
+ insertUser.run("usr_owner", "owner", await hashPassword("owner-password"), "Owner");
+ insertUser.run("usr_member", "writer", await hashPassword("writer-password"), "Writer");
+ sqlite.query("INSERT INTO api_tokens (id, name, token_hash, scopes_json, workspace_id) VALUES (?, ?, ?, ?, ?)")
+ .run("tok_agent", "Agent", await sha256("agent-token"), JSON.stringify(["read:memos"]), "ws_default");
+
+ const app = createApp({
+ authenticateRequest,
+ authenticateSession,
+ createSession,
+ ensureUserWorkspace,
+ getBearerToken,
+ getInstanceAuthMode,
+ getLoginAttemptKeys,
+ revokeSession,
+ setSessionCookie,
+ tooManyLoginAttempts,
+ verifyLogin,
+ });
+ const realEnvironment = { storage: createSelfHostedStorageAdapter(sqlite, "/tmp/edgeever-auth-sessions-unused") };
+
+ const request = (path, { token, cookie, method = "GET", body, headers = {} } = {}) => app.request(path, {
+ method,
+ headers: {
+ ...(token ? { Authorization: `Bearer ${token}` } : {}),
+ ...(cookie ? { Cookie: `edgeever_session=${cookie}` } : {}),
+ ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+ ...headers,
+ },
+ body: body === undefined ? undefined : JSON.stringify(body),
+ }, realEnvironment);
+ const login = async (username, password, deviceId, headers = {}) => {
+ const response = await request("/api/v1/auth/login", {
+ method: "POST",
+ body: { username, password, deviceId },
+ headers,
+ });
+ expect(response.status).toBe(200);
+ const token = (await response.json()).sessionToken;
+ const session = sqlite.query("SELECT id FROM sessions WHERE token_hash = ?").get(await sha256(token));
+ return { token, id: session.id, response };
+ };
+ const insertSession = (id, userId, deviceId, { expiresAt, revokedAt = null, createdAt } = {}) => {
+ sqlite.query(
+ `INSERT INTO sessions (id, user_id, token_hash, device_id, expires_at, revoked_at, created_at, last_seen_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+ ).run(
+ id,
+ userId,
+ `hash-${id}`,
+ deviceId,
+ expiresAt ?? new Date(Date.now() + DAY_MS).toISOString(),
+ revokedAt,
+ createdAt ?? "2026-01-01T00:00:00.000Z",
+ createdAt ?? "2026-01-01T00:00:00.000Z",
+ );
+ };
+ const session = (id) => sqlite.query("SELECT device_label, revoked_at FROM sessions WHERE id = ?").get(id);
+ const listSessions = async (token) => {
+ const response = await request("/api/v1/auth/sessions", { token });
+ expect(response.status).toBe(200);
+ return (await response.json()).sessions;
+ };
+
+ return { sqlite, request, login, insertSession, session, listSessions };
+ };
+
+ test("lists only the caller's active sessions grouped by device with the current one flagged", async () => {
+ const instance = await createInstance();
+ const a = await instance.login("owner", "owner-password", DEVICE_A, { "User-Agent": "Desktop A" });
+ const b = await instance.login("owner", "owner-password", DEVICE_B, { "User-Agent": "Phone B" });
+ const member = await instance.login("writer", "writer-password", DEVICE_C);
+ instance.insertSession("sess_a_older", "usr_owner", DEVICE_A);
+ instance.insertSession("sess_expired", "usr_owner", "device-expired-000001", {
+ expiresAt: new Date(Date.now() - DAY_MS).toISOString(),
+ });
+ instance.insertSession("sess_revoked", "usr_owner", "device-revoked-000001", {
+ revokedAt: "2026-01-02T00:00:00.000Z",
+ });
+
+ const fromA = await instance.listSessions(a.token);
+ expect(fromA.map((entry) => entry.id).sort()).toEqual([a.id, b.id].sort());
+ expect(fromA.find((entry) => entry.id === a.id)).toMatchObject({
+ isCurrent: true,
+ userAgent: "Desktop A",
+ createdAt: "2026-01-01T00:00:00.000Z",
+ });
+ expect(fromA.find((entry) => entry.id === b.id)).toMatchObject({ isCurrent: false, userAgent: "Phone B" });
+ expect(JSON.stringify(fromA)).not.toContain("token");
+
+ const fromB = await instance.listSessions(b.token);
+ expect(fromB.filter((entry) => entry.isCurrent).map((entry) => entry.id)).toEqual([b.id]);
+
+ const fromMember = await instance.listSessions(member.token);
+ expect(fromMember.map((entry) => [entry.id, entry.isCurrent])).toEqual([[member.id, true]]);
+ });
+
+ test("records a new login and replaces the previous session on the same device", async () => {
+ const instance = await createInstance();
+ const first = await instance.login("owner", "owner-password", DEVICE_A);
+ const second = await instance.login("owner", "owner-password", DEVICE_A, {
+ "CF-Connecting-IP": "203.0.113.7",
+ "CF-IPCountry": "PL",
+ "User-Agent": "Desktop A",
+ });
+
+ expect(instance.session(first.id).revoked_at).not.toBeNull();
+ expect((await instance.request("/api/v1/auth/sessions", { token: first.token })).status).toBe(401);
+
+ const row = instance.sqlite.query("SELECT * FROM sessions WHERE id = ?").get(second.id);
+ expect(row).toMatchObject({
+ user_id: "usr_owner",
+ device_id: DEVICE_A,
+ user_agent: "Desktop A",
+ ip_address: "203.0.113.7",
+ ip_hash: await sha256("203.0.113.7"),
+ ip_country: "PL",
+ revoked_at: null,
+ });
+ expect(row.token_hash).toBe(await sha256(second.token));
+ expect(Date.parse(row.expires_at) - Date.now()).toBeGreaterThan(399 * DAY_MS);
+ expect(Date.parse(row.expires_at) - Date.now()).toBeLessThanOrEqual(400 * DAY_MS);
+
+ const cookie = second.response.headers.get("set-cookie");
+ expect(cookie).toContain(`edgeever_session=${second.token}`);
+ expect(cookie).toContain("HttpOnly");
+ expect(cookie).toContain("SameSite=Lax");
+ expect(cookie).toContain(`Max-Age=${400 * 24 * 60 * 60}`);
+ expect(cookie).not.toContain("Secure");
+
+ const sessions = await instance.listSessions(second.token);
+ expect(sessions.map((entry) => [entry.id, entry.isCurrent])).toEqual([[second.id, true]]);
+ });
+
+ test("authenticates session endpoints with the session cookie and revokes it on logout", async () => {
+ const instance = await createInstance();
+ const login = await instance.login("owner", "owner-password", DEVICE_A);
+
+ const listed = await instance.request("/api/v1/auth/sessions", { cookie: login.token });
+ expect(listed.status).toBe(200);
+ expect((await listed.json()).sessions.map((entry) => entry.isCurrent)).toEqual([true]);
+
+ const logout = await instance.request("/api/v1/auth/logout", { method: "POST", cookie: login.token });
+ expect(logout.status).toBe(200);
+ expect(instance.session(login.id).revoked_at).not.toBeNull();
+ expect((await instance.request("/api/v1/auth/sessions", { cookie: login.token })).status).toBe(401);
+ });
+
+ test("renames the caller's own sessions per device and never another user's", async () => {
+ const instance = await createInstance();
+ const a = await instance.login("owner", "owner-password", DEVICE_A);
+ const b = await instance.login("owner", "owner-password", DEVICE_B);
+ const member = await instance.login("writer", "writer-password", DEVICE_C);
+ instance.insertSession("sess_b_older", "usr_owner", DEVICE_B);
+ instance.insertSession("sess_legacy", "usr_owner", null);
+ const rename = (sessionId, body, token = a.token) => instance.request(`/api/v1/auth/sessions/${sessionId}`, {
+ token,
+ method: "PATCH",
+ body,
+ });
+
+ const renamed = await rename(b.id, { label: " Work phone " });
+ expect(renamed.status).toBe(200);
+ expect(await renamed.json()).toEqual({ ok: true });
+ expect(instance.session(b.id).device_label).toBe("Work phone");
+ expect(instance.session("sess_b_older").device_label).toBe("Work phone");
+ expect((await instance.listSessions(a.token)).find((entry) => entry.id === b.id).label).toBe("Work phone");
+ expect(instance.sqlite.query(
+ "SELECT actor_id, entity_id, metadata_json FROM audit_events WHERE action = 'auth.session_label_update'",
+ ).get()).toEqual({ actor_id: "usr_owner", entity_id: b.id, metadata_json: JSON.stringify({ label: "Work phone" }) });
+
+ expect((await rename("sess_legacy", { label: "Old laptop" })).status).toBe(200);
+ expect(instance.session("sess_legacy").device_label).toBe("Old laptop");
+ expect((await rename(a.id, { label: "This desktop" })).status).toBe(200);
+ expect(instance.session(a.id).device_label).toBe("This desktop");
+
+ expect((await rename(b.id, { label: " " })).status).toBe(200);
+ expect(instance.session(b.id).device_label).toBeNull();
+ expect((await rename("sess_legacy", { label: null })).status).toBe(200);
+ expect(instance.session("sess_legacy").device_label).toBeNull();
+
+ for (const body of [{}, { label: "x".repeat(81) }, { label: 7 }]) {
+ expect((await rename(b.id, body)).status).toBe(400);
+ }
+
+ const foreign = await rename(member.id, { label: "Hijacked" });
+ expect(foreign.status).toBe(404);
+ expect(instance.session(member.id).device_label).toBeNull();
+ expect((await rename(a.id, { label: "Hijacked" }, member.token)).status).toBe(404);
+ expect(instance.session(a.id).device_label).toBe("This desktop");
+ expect((await rename("sess_missing", { label: "Ghost" })).status).toBe(404);
+ });
+
+ test("revokes a single other session or device but not the current device or another user's session", async () => {
+ const instance = await createInstance();
+ const a = await instance.login("owner", "owner-password", DEVICE_A);
+ const b = await instance.login("owner", "owner-password", DEVICE_B);
+ const c = await instance.login("owner", "owner-password", DEVICE_C);
+ const member = await instance.login("writer", "writer-password", DEVICE_A);
+ instance.insertSession("sess_c_older", "usr_owner", DEVICE_C);
+ instance.insertSession("sess_a_older", "usr_owner", DEVICE_A);
+ const revoke = (sessionId, token = a.token) => instance.request(`/api/v1/auth/sessions/${sessionId}`, {
+ token,
+ method: "DELETE",
+ });
+
+ const foreign = await revoke(member.id);
+ expect(foreign.status).toBe(404);
+ expect(instance.session(member.id).revoked_at).toBeNull();
+ expect((await revoke(a.id, member.token)).status).toBe(404);
+ expect(instance.session(a.id).revoked_at).toBeNull();
+
+ const sameDevice = await revoke("sess_a_older");
+ expect(sameDevice.status).toBe(400);
+ expect(await sameDevice.json()).toMatchObject({ error: { code: "current_session_cannot_be_revoked" } });
+ expect(instance.session("sess_a_older").revoked_at).toBeNull();
+ expect((await revoke(a.id)).status).toBe(400);
+
+ const single = await revoke(b.id);
+ expect(single.status).toBe(200);
+ expect(instance.session(b.id).revoked_at).not.toBeNull();
+ expect((await instance.request("/api/v1/auth/sessions", { token: b.token })).status).toBe(401);
+ expect((await revoke(b.id)).status).toBe(404);
+
+ expect((await revoke(c.id)).status).toBe(200);
+ expect(instance.session(c.id).revoked_at).not.toBeNull();
+ expect(instance.session("sess_c_older").revoked_at).not.toBeNull();
+
+ expect(instance.session(a.id).revoked_at).toBeNull();
+ expect(instance.session(member.id).revoked_at).toBeNull();
+ expect((await instance.listSessions(a.token)).map((entry) => [entry.id, entry.isCurrent])).toEqual([[a.id, true]]);
+ expect(instance.sqlite.query(
+ "SELECT entity_id FROM audit_events WHERE action = 'auth.session_revoke' ORDER BY rowid",
+ ).all().map((row) => row.entity_id)).toEqual([b.id, c.id]);
+ });
+
+ test("signs out every other session of the caller only", async () => {
+ const instance = await createInstance();
+ const a = await instance.login("owner", "owner-password", DEVICE_A);
+ const b = await instance.login("owner", "owner-password", DEVICE_B);
+ const c = await instance.login("owner", "owner-password", DEVICE_C);
+ const member = await instance.login("writer", "writer-password", DEVICE_B);
+ instance.insertSession("sess_expired", "usr_owner", "device-expired-000001", {
+ expiresAt: new Date(Date.now() - DAY_MS).toISOString(),
+ });
+
+ const response = await instance.request("/api/v1/auth/sessions", { token: a.token, method: "DELETE" });
+
+ expect(response.status).toBe(200);
+ expect(await response.json()).toEqual({ ok: true });
+ expect(instance.session(a.id).revoked_at).toBeNull();
+ expect(instance.session(b.id).revoked_at).not.toBeNull();
+ expect(instance.session(c.id).revoked_at).not.toBeNull();
+ expect(instance.session("sess_expired").revoked_at).toBeNull();
+ expect(instance.session(member.id).revoked_at).toBeNull();
+ expect((await instance.request("/api/v1/auth/sessions", { token: b.token })).status).toBe(401);
+ expect((await instance.listSessions(a.token)).map((entry) => entry.id)).toEqual([a.id]);
+ expect((await instance.listSessions(member.token)).map((entry) => entry.id)).toEqual([member.id]);
+ expect(instance.sqlite.query(
+ "SELECT actor_id, entity_id FROM audit_events WHERE action = 'auth.sessions_revoke_others'",
+ ).all()).toEqual([{ actor_id: "usr_owner", entity_id: a.id }]);
+ });
+
+ test("refuses session management to API tokens and anonymous callers", async () => {
+ const instance = await createInstance();
+ const a = await instance.login("owner", "owner-password", DEVICE_A);
+ const b = await instance.login("owner", "owner-password", DEVICE_B);
+
+ for (const token of ["agent-token", "unknown-token", undefined]) {
+ for (const [path, options] of [
+ ["/api/v1/auth/sessions", { method: "GET" }],
+ [`/api/v1/auth/sessions/${b.id}`, { method: "PATCH", body: { label: "Agent" } }],
+ [`/api/v1/auth/sessions/${b.id}`, { method: "DELETE" }],
+ ["/api/v1/auth/sessions", { method: "DELETE" }],
+ ]) {
+ const response = await instance.request(path, { ...options, token });
+ expect(response.status).toBe(401);
+ expect(await response.json()).toMatchObject({ error: { code: "unauthorized" } });
+ }
+ }
+
+ expect(instance.session(a.id)).toEqual({ device_label: null, revoked_at: null });
+ expect(instance.session(b.id)).toEqual({ device_label: null, revoked_at: null });
+ });
+});
diff --git a/apps/api/src/memo-trash.test.mjs b/apps/api/src/memo-trash.test.mjs
new file mode 100644
index 00000000..fc53a77c
--- /dev/null
+++ b/apps/api/src/memo-trash.test.mjs
@@ -0,0 +1,553 @@
+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" },
+ ]);
+ });
+});
diff --git a/apps/api/src/object-storage-routes.test.mjs b/apps/api/src/object-storage-routes.test.mjs
index 9f2d6093..ed2d3262 100644
--- a/apps/api/src/object-storage-routes.test.mjs
+++ b/apps/api/src/object-storage-routes.test.mjs
@@ -1,6 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { afterEach, describe, expect, test } from "bun:test";
+import { globSync, readFileSync } from "node:fs";
import { Hono } from "hono";
+import { AppError } from "./app-error.ts";
+import { apiError } from "./http-errors.ts";
+import { resolvePrimaryObjectStorageEncryptionKey } from "./object-storage.ts";
import { registerObjectStorageRoutes } from "./object-storage-routes.ts";
+import { decryptSecret, encryptSecret } from "./secret-encryption.ts";
+import { createSelfHostedStorageAdapter } from "./self-hosted-storage-adapter.ts";
const auth = {
kind: "user",
@@ -62,3 +69,492 @@ describe("object storage route contracts", () => {
expect(await response.json()).toMatchObject({ error: { code: "forbidden" } });
});
});
+
+const FAKE_AUTH_PASSWORD = "fake-instance-auth-password";
+const FAKE_SECRET = "FAKE-secret-access-key-do-not-use";
+const authEnvironment = { EDGE_EVER_AUTH_PASSWORD: FAKE_AUTH_PASSWORD };
+const primaryKey = resolvePrimaryObjectStorageEncryptionKey(authEnvironment);
+
+const originalFetch = globalThis.fetch;
+afterEach(() => { globalThis.fetch = originalFetch; });
+
+// In-memory S3 double: records every signed request and answers the connection probe.
+const stubS3 = ({ failWith } = {}) => {
+ const objects = new Map();
+ const requests = [];
+ globalThis.fetch = async (request) => {
+ requests.push({
+ method: request.method,
+ url: request.url,
+ authorization: request.headers.get("authorization"),
+ });
+ if (failWith) return new Response(failWith.body, { status: failWith.status });
+ if (request.method === "PUT") {
+ objects.set(request.url, new Uint8Array(await request.arrayBuffer()));
+ return new Response(null, { status: 200 });
+ }
+ if (request.method === "GET") {
+ const value = objects.get(request.url);
+ return value ? new Response(value, { status: 200 }) : new Response(null, { status: 404 });
+ }
+ if (request.method === "DELETE") {
+ objects.delete(request.url);
+ return new Response(null, { status: 204 });
+ }
+ return new Response(null, { status: 405 });
+ };
+ return { objects, requests };
+};
+
+const installation = ({ currentAuth = auth, env = authEnvironment } = {}) => {
+ const sqlite = new Database(":memory:");
+ for (const path of globSync("migrations/*.sql").sort()) sqlite.exec(readFileSync(path, "utf8"));
+ const app = new Hono();
+ app.onError((error, context) => error instanceof AppError
+ ? apiError(context, error.code, error.message, error.status)
+ : context.json({ error: { code: "internal_error", message: error.message } }, 500));
+ app.use("/api/v1/*", async (context, next) => {
+ context.set("auth", currentAuth);
+ await next();
+ });
+ registerObjectStorageRoutes(app, { isDemoMode: () => false });
+ const environment = {
+ ...env,
+ storage: createSelfHostedStorageAdapter(sqlite, "/tmp/edgeever-object-storage-route-test-unused"),
+ };
+ const request = (path, { method = "GET", body } = {}) => app.request(
+ path,
+ body === undefined
+ ? { method }
+ : { method, headers: { "content-type": "application/json" }, body: JSON.stringify(body) },
+ environment,
+ );
+ const configs = () => sqlite.query(
+ "SELECT id, provider, endpoint, region, bucket, access_key_id, secret_access_key_encrypted, force_path_style, object_prefix, is_active FROM object_storage_configs ORDER BY id",
+ ).all();
+ const audits = () => sqlite.query(
+ "SELECT actor_id, action, entity_id, metadata_json FROM audit_events WHERE action = 'instance.object_storage.update' ORDER BY rowid",
+ ).all();
+ return { sqlite, app, request, configs, audits };
+};
+
+const s3Settings = (overrides = {}) => ({
+ provider: "s3",
+ displayName: "Fake S3",
+ endpoint: "https://objects.example.test",
+ region: "us-east-1",
+ bucket: "edgeever-fake",
+ accessKeyId: "FAKE-access-key-id",
+ secretAccessKey: FAKE_SECRET,
+ forcePathStyle: true,
+ objectPrefix: "notes",
+ ...overrides,
+});
+
+const insertS3Config = async (sqlite, { encryptedSecret, isActive = false } = {}) => {
+ if (isActive) sqlite.exec("UPDATE object_storage_configs SET is_active = 0");
+ sqlite.query(
+ `INSERT INTO object_storage_configs (
+ id, provider, display_name, endpoint, region, bucket, access_key_id,
+ secret_access_key_encrypted, force_path_style, object_prefix, is_active
+ ) VALUES ('instance-s3', 's3', 'Fake S3', 'https://objects.example.test', 'us-east-1',
+ 'edgeever-fake', 'FAKE-access-key-id', ?, 1, 'notes', ?)`,
+ ).run(encryptedSecret ?? await encryptSecret(FAKE_SECRET, primaryKey), isActive ? 1 : 0);
+};
+
+describe("object storage settings on a migrated database", () => {
+ test("returns the built-in storage settings without an external configuration", async () => {
+ const { request, sqlite } = installation();
+ const response = await request("/api/v1/instance/object-storage");
+
+ expect(response.status).toBe(200);
+ expect(await response.json()).toEqual({
+ settings: {
+ provider: "builtin",
+ displayName: "Built-in object storage",
+ endpoint: null,
+ region: null,
+ bucket: null,
+ accessKeyId: null,
+ hasSecretAccessKey: false,
+ forcePathStyle: true,
+ objectPrefix: "",
+ encryptionConfigured: true,
+ },
+ externalSettings: null,
+ });
+ sqlite.close();
+ });
+
+ test("reports encryption as unconfigured when only the legacy storage key is present", async () => {
+ const { request, sqlite } = installation({ env: { EDGE_EVER_STORAGE_ENCRYPTION_KEY: "fake-legacy-key" } });
+ const body = await (await request("/api/v1/instance/object-storage")).json();
+
+ expect(body.settings.encryptionConfigured).toBe(false);
+ sqlite.close();
+ });
+
+ test("returns 404 when no storage configuration is active", async () => {
+ const { request, sqlite } = installation();
+ sqlite.exec("UPDATE object_storage_configs SET is_active = 0");
+ const response = await request("/api/v1/instance/object-storage");
+
+ expect(response.status).toBe(404);
+ expect(await response.json()).toMatchObject({ error: { code: "not_found" } });
+ sqlite.close();
+ });
+
+ for (const [label, currentAuth] of [
+ ["workspace members", { ...auth, actorId: "usr_member", role: "member" }],
+ ["API tokens", { ...auth, kind: "agent", actorType: "agent", actorId: "tok_owner", scopes: ["write:resources"], role: "owner" }],
+ ]) {
+ test(`rejects ${label} on every storage route without touching storage`, async () => {
+ const { request, configs, audits, sqlite } = installation({ currentAuth });
+ const s3 = stubS3();
+ const before = configs();
+
+ for (const [method, path, body] of [
+ ["GET", "/api/v1/instance/object-storage"],
+ ["PUT", "/api/v1/instance/object-storage", s3Settings()],
+ ["PUT", "/api/v1/instance/object-storage", { provider: "builtin" }],
+ ["POST", "/api/v1/instance/object-storage/test", s3Settings()],
+ ]) {
+ const response = await request(path, { method, body });
+ expect(response.status).toBe(403);
+ expect(await response.json()).toMatchObject({ error: { code: "forbidden" } });
+ }
+ expect(s3.requests).toHaveLength(0);
+ expect(configs()).toEqual(before);
+ expect(audits()).toHaveLength(0);
+ sqlite.close();
+ });
+ }
+
+ test("saves verified S3 settings with an encrypted secret that is never returned", async () => {
+ const { request, configs, audits, sqlite } = installation();
+ const s3 = stubS3();
+ const response = await request("/api/v1/instance/object-storage", {
+ method: "PUT",
+ body: s3Settings({
+ endpoint: "https://objects.example.test/",
+ forcePathStyle: false,
+ objectPrefix: "/team/notes/",
+ }),
+ });
+
+ expect(response.status).toBe(200);
+ const text = await response.text();
+ expect(text).not.toContain(FAKE_SECRET);
+ expect(JSON.parse(text)).toEqual({
+ settings: {
+ provider: "s3",
+ displayName: "Fake S3",
+ endpoint: "https://objects.example.test",
+ region: "us-east-1",
+ bucket: "edgeever-fake",
+ accessKeyId: "FAKE-access-key-id",
+ hasSecretAccessKey: true,
+ forcePathStyle: false,
+ objectPrefix: "team/notes",
+ encryptionConfigured: true,
+ },
+ });
+
+ // The connection probe ran against the virtual-hosted bucket before anything was saved.
+ expect(s3.requests.map((entry) => entry.method)).toEqual(["PUT", "GET", "DELETE"]);
+ const probeUrl = new URL(s3.requests[0].url);
+ expect(probeUrl.hostname).toBe("edgeever-fake.objects.example.test");
+ expect(probeUrl.pathname).toStartWith("/team/notes/.edgeever-connection-test/");
+ expect(s3.requests[0].authorization).toContain("Credential=FAKE-access-key-id/");
+ expect(s3.objects.size).toBe(0);
+
+ const rows = configs();
+ expect(rows.map((row) => [row.id, row.is_active])).toEqual([["builtin", 0], ["instance-s3", 1]]);
+ const saved = rows[1];
+ expect(saved).toMatchObject({
+ endpoint: "https://objects.example.test",
+ force_path_style: 0,
+ object_prefix: "team/notes",
+ });
+ expect(saved.secret_access_key_encrypted).toStartWith("v1.");
+ expect(saved.secret_access_key_encrypted).not.toContain(FAKE_SECRET);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM object_storage_configs WHERE secret_access_key_encrypted LIKE ?")
+ .get(`%${FAKE_SECRET}%`).count).toBe(0);
+ expect(await decryptSecret(saved.secret_access_key_encrypted, primaryKey)).toBe(FAKE_SECRET);
+
+ const [audit] = audits();
+ expect(audit).toMatchObject({ actor_id: "usr_owner", entity_id: "instance-s3" });
+ expect(JSON.parse(audit.metadata_json)).toEqual({
+ provider: "s3",
+ endpoint: "https://objects.example.test",
+ bucket: "edgeever-fake",
+ });
+
+ const read = await request("/api/v1/instance/object-storage");
+ const readText = await read.text();
+ expect(readText).not.toContain(FAKE_SECRET);
+ expect(readText).not.toContain(saved.secret_access_key_encrypted);
+ const readBody = JSON.parse(readText);
+ expect(readBody.settings).toEqual(readBody.externalSettings);
+ expect(readBody.settings).toMatchObject({ provider: "s3", hasSecretAccessKey: true });
+ expect(readBody.settings).not.toHaveProperty("secretAccessKey");
+ sqlite.close();
+ });
+
+ test("keeps the saved secret when an update omits it", async () => {
+ const { request, configs, sqlite } = installation();
+ await insertS3Config(sqlite, { isActive: true });
+ const s3 = stubS3();
+
+ const response = await request("/api/v1/instance/object-storage", {
+ method: "PUT",
+ body: s3Settings({ secretAccessKey: undefined, bucket: "edgeever-renamed" }),
+ });
+
+ expect(response.status).toBe(200);
+ expect((await response.json()).settings).toMatchObject({ bucket: "edgeever-renamed", hasSecretAccessKey: true });
+ expect(s3.requests).toHaveLength(3);
+ const saved = configs().find((row) => row.id === "instance-s3");
+ expect(saved.bucket).toBe("edgeever-renamed");
+ expect(await decryptSecret(saved.secret_access_key_encrypted, primaryKey)).toBe(FAKE_SECRET);
+ sqlite.close();
+ });
+
+ test("requires a secret for the first S3 configuration", async () => {
+ const { request, configs, sqlite } = installation();
+ const s3 = stubS3();
+ const before = configs();
+
+ const response = await request("/api/v1/instance/object-storage", {
+ method: "PUT",
+ body: s3Settings({ secretAccessKey: undefined }),
+ });
+
+ expect(response.status).toBe(400);
+ expect(await response.json()).toMatchObject({ error: { code: "object_storage_secret_required" } });
+ expect(s3.requests).toHaveLength(0);
+ expect(configs()).toEqual(before);
+ sqlite.close();
+ });
+
+ test("refuses to store external credentials without an instance authentication secret", async () => {
+ const { request, configs, sqlite } = installation({
+ env: { EDGE_EVER_STORAGE_ENCRYPTION_KEY: "fake-legacy-key" },
+ });
+ const s3 = stubS3();
+ const before = configs();
+
+ const response = await request("/api/v1/instance/object-storage", { method: "PUT", body: s3Settings() });
+
+ expect(response.status).toBe(400);
+ expect(await response.json()).toMatchObject({ error: { code: "object_storage_authentication_required" } });
+ expect(s3.requests).toHaveLength(0);
+ expect(configs()).toEqual(before);
+ sqlite.close();
+ });
+
+ test("keeps the current storage active when the connection probe fails", async () => {
+ const { request, configs, audits, sqlite } = installation();
+ const s3 = stubS3({ failWith: { status: 403, body: "<Error><Code>AccessDenied</Code></Error>" } });
+ const before = configs();
+
+ const response = await request("/api/v1/instance/object-storage", { method: "PUT", body: s3Settings() });
+
+ expect(response.status).toBe(400);
+ const text = await response.text();
+ expect(text).not.toContain(FAKE_SECRET);
+ expect(JSON.parse(text)).toMatchObject({
+ error: { code: "object_storage_connection_failed", message: expect.stringContaining("Object upload failed (403)") },
+ });
+ expect(s3.requests).toHaveLength(1);
+ expect(configs()).toEqual(before);
+ expect(audits()).toHaveLength(0);
+ sqlite.close();
+ });
+
+ for (const [label, overrides] of [
+ ["a non-HTTP endpoint", { endpoint: "ftp://objects.example.test" }],
+ ["a malformed endpoint", { endpoint: "not a url" }],
+ ["an oversized endpoint", { endpoint: `https://objects.example.test/${"a".repeat(500)}` }],
+ ["an empty bucket", { bucket: " " }],
+ ["an oversized bucket", { bucket: "b".repeat(256) }],
+ ["an empty region", { region: "" }],
+ ["an empty access key ID", { accessKeyId: "" }],
+ ["an empty secret", { secretAccessKey: "" }],
+ ["an oversized object prefix", { objectPrefix: "p".repeat(501) }],
+ ["a non-boolean path-style flag", { forcePathStyle: "yes" }],
+ ["a missing display name", { displayName: undefined }],
+ ["an unknown provider", { provider: "gcs" }],
+ ]) {
+ test(`rejects S3 settings with ${label}`, async () => {
+ const { request, configs, sqlite } = installation();
+ const s3 = stubS3();
+ const before = configs();
+
+ const response = await request("/api/v1/instance/object-storage", {
+ method: "PUT",
+ body: s3Settings(overrides),
+ });
+
+ expect(response.status).toBe(400);
+ expect(await response.text()).not.toContain(FAKE_SECRET);
+ expect(s3.requests).toHaveLength(0);
+ expect(configs()).toEqual(before);
+ sqlite.close();
+ });
+ }
+
+ test("switches back to built-in storage and keeps the external configuration for existing files", async () => {
+ const { request, configs, audits, sqlite } = installation();
+ await insertS3Config(sqlite, { isActive: true });
+ const before = configs().find((row) => row.id === "instance-s3");
+ const s3 = stubS3();
+
+ const response = await request("/api/v1/instance/object-storage", {
+ method: "PUT",
+ body: { provider: "builtin" },
+ });
+
+ expect(response.status).toBe(200);
+ expect((await response.json()).settings).toMatchObject({ provider: "builtin", hasSecretAccessKey: false });
+ expect(s3.requests).toHaveLength(0);
+ const rows = configs();
+ expect(rows.map((row) => [row.id, row.is_active])).toEqual([["builtin", 1], ["instance-s3", 0]]);
+ expect(rows[1]).toEqual({ ...before, is_active: 0 });
+ expect(audits().map((audit) => [audit.entity_id, JSON.parse(audit.metadata_json)]))
+ .toEqual([["builtin", { provider: "builtin" }]]);
+
+ const read = await (await request("/api/v1/instance/object-storage")).json();
+ expect(read.settings.provider).toBe("builtin");
+ expect(read.externalSettings).toMatchObject({ provider: "s3", bucket: "edgeever-fake", hasSecretAccessKey: true });
+ sqlite.close();
+ });
+
+ test("migrates a legacy-key secret to the primary key when it is reused", async () => {
+ const legacyKey = "fake-legacy-storage-key";
+ const { request, configs, sqlite } = installation({
+ env: { ...authEnvironment, EDGE_EVER_STORAGE_ENCRYPTION_KEY: legacyKey },
+ });
+ const legacyCiphertext = await encryptSecret(FAKE_SECRET, legacyKey);
+ await insertS3Config(sqlite, { encryptedSecret: legacyCiphertext });
+ stubS3();
+
+ const response = await request("/api/v1/instance/object-storage/test", {
+ method: "POST",
+ body: s3Settings({ secretAccessKey: undefined }),
+ });
+
+ expect(response.status).toBe(200);
+ const stored = configs().find((row) => row.id === "instance-s3").secret_access_key_encrypted;
+ expect(stored).not.toBe(legacyCiphertext);
+ expect(await decryptSecret(stored, primaryKey)).toBe(FAKE_SECRET);
+ sqlite.close();
+ });
+
+ test("returns 503 instead of leaking or crashing when the saved secret cannot be decrypted", async () => {
+ const { request, configs, sqlite } = installation();
+ const foreignCiphertext = await encryptSecret(FAKE_SECRET, "fake-key-from-another-instance");
+ await insertS3Config(sqlite, { encryptedSecret: foreignCiphertext, isActive: true });
+ const s3 = stubS3();
+ const before = configs();
+
+ for (const [method, path] of [
+ ["POST", "/api/v1/instance/object-storage/test"],
+ ["PUT", "/api/v1/instance/object-storage"],
+ ]) {
+ const response = await request(path, { method, body: s3Settings({ secretAccessKey: undefined }) });
+ expect(response.status).toBe(503);
+ const text = await response.text();
+ expect(text).not.toContain(FAKE_SECRET);
+ expect(text).not.toContain(foreignCiphertext);
+ expect(JSON.parse(text)).toMatchObject({ error: { code: "object_storage_unavailable" } });
+ }
+ expect(s3.requests).toHaveLength(0);
+ expect(configs()).toEqual(before);
+ sqlite.close();
+ });
+});
+
+describe("object storage connection test route", () => {
+ test("verifies a submitted configuration without saving it", async () => {
+ const { request, configs, audits, sqlite } = installation();
+ const s3 = stubS3();
+ const before = configs();
+
+ const response = await request("/api/v1/instance/object-storage/test", {
+ method: "POST",
+ body: s3Settings({ endpoint: "https://objects.example.test//", provider: undefined, displayName: undefined }),
+ });
+
+ expect(response.status).toBe(200);
+ expect(await response.json()).toEqual({ ok: true });
+ expect(s3.requests.map((entry) => entry.method)).toEqual(["PUT", "GET", "DELETE"]);
+ expect(new URL(s3.requests[0].url).pathname).toStartWith("/edgeever-fake/notes/.edgeever-connection-test/");
+ expect(configs()).toEqual(before);
+ expect(audits()).toHaveLength(0);
+ sqlite.close();
+ });
+
+ test("reports provider failures as a connection error", async () => {
+ const { request, sqlite } = installation();
+ // 4xx on purpose: aws4fetch retries 5xx responses with backoff.
+ stubS3({ failWith: { status: 404, body: "<Error>\n NoSuchBucket\n</Error>" } });
+
+ const response = await request("/api/v1/instance/object-storage/test", { method: "POST", body: s3Settings() });
+
+ expect(response.status).toBe(400);
+ const text = await response.text();
+ expect(text).not.toContain(FAKE_SECRET);
+ expect(JSON.parse(text)).toEqual({
+ error: { code: "object_storage_connection_failed", message: "Object upload failed (404): <Error> NoSuchBucket </Error>" },
+ });
+ sqlite.close();
+ });
+
+ test("reports a probe whose read-back content does not match", async () => {
+ const { request, sqlite } = installation();
+ const methods = [];
+ globalThis.fetch = async (probe) => {
+ methods.push(probe.method);
+ return probe.method === "GET" ? new Response("different", { status: 200 }) : new Response(null, { status: 200 });
+ };
+
+ const response = await request("/api/v1/instance/object-storage/test", { method: "POST", body: s3Settings() });
+
+ expect(response.status).toBe(400);
+ expect(await response.json()).toMatchObject({
+ error: { code: "object_storage_connection_failed", message: "The test object content did not match after upload." },
+ });
+ expect(methods).toEqual(["PUT", "GET", "DELETE"]);
+ sqlite.close();
+ });
+
+ test("requires a secret when none has been saved", async () => {
+ const { request, sqlite } = installation();
+ const s3 = stubS3();
+
+ const response = await request("/api/v1/instance/object-storage/test", {
+ method: "POST",
+ body: s3Settings({ secretAccessKey: undefined }),
+ });
+
+ expect(response.status).toBe(400);
+ expect(await response.json()).toMatchObject({ error: { code: "object_storage_secret_required" } });
+ expect(s3.requests).toHaveLength(0);
+ sqlite.close();
+ });
+
+ test("rejects an invalid endpoint before contacting storage", async () => {
+ const { request, sqlite } = installation();
+ const s3 = stubS3();
+
+ const response = await request("/api/v1/instance/object-storage/test", {
+ method: "POST",
+ body: s3Settings({ endpoint: "javascript:alert(1)" }),
+ });
+
+ expect(response.status).toBe(400);
+ expect(s3.requests).toHaveLength(0);
+ sqlite.close();
+ });
+});
diff --git a/apps/api/src/object-storage.test.mjs b/apps/api/src/object-storage.test.mjs
index 3d1173e0..8a7f05b7 100644
--- a/apps/api/src/object-storage.test.mjs
+++ b/apps/api/src/object-storage.test.mjs
@@ -1,10 +1,17 @@
-import { describe, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { afterEach, describe, expect, test } from "bun:test";
+import { globSync, readFileSync } from "node:fs";
import {
+ deleteStoredObjects,
+ getActiveObjectStorageConfig,
+ getObjectStorageConfig,
+ resolveObjectStorage,
resolveObjectStorageEncryptionKeys,
resolvePrimaryObjectStorageEncryptionKey,
resolveStoredObjectStorageSecret,
} from "./object-storage.ts";
import { decryptSecret, encryptSecret } from "./secret-encryption.ts";
+import { createSelfHostedStorageAdapter } from "./self-hosted-storage-adapter.ts";
const objectStorageRow = (encryptedSecret) => ({
id: "instance-s3",
@@ -100,3 +107,268 @@ describe("object storage credential encryption", () => {
expect(database.updates).toHaveLength(0);
});
});
+
+const FAKE_SECRET = "FAKE-secret-access-key-do-not-use";
+const authEnvironment = { EDGE_EVER_AUTH_PASSWORD: "fake-instance-auth-password" };
+const primaryKey = resolvePrimaryObjectStorageEncryptionKey(authEnvironment);
+
+const originalFetch = globalThis.fetch;
+afterEach(() => { globalThis.fetch = originalFetch; });
+
+const recordS3Requests = () => {
+ const requests = [];
+ globalThis.fetch = async (request) => {
+ requests.push({ method: request.method, url: request.url });
+ return new Response(null, { status: request.method === "DELETE" ? 204 : 200 });
+ };
+ return requests;
+};
+
+const builtinStore = () => {
+ const deleted = [];
+ return {
+ deleted,
+ get: async () => null,
+ put: async () => undefined,
+ createMultipartUpload: async () => { throw new Error("unused"); },
+ resumeMultipartUpload: () => { throw new Error("unused"); },
+ delete: async (keys) => { deleted.push(keys); },
+ };
+};
+
+const installation = ({ env = authEnvironment } = {}) => {
+ const sqlite = new Database(":memory:");
+ for (const path of globSync("migrations/*.sql").sort()) sqlite.exec(readFileSync(path, "utf8"));
+ const resources = builtinStore();
+ const environment = {
+ ...env,
+ storage: {
+ db: createSelfHostedStorageAdapter(sqlite, "/tmp/edgeever-object-storage-test-unused").db,
+ resources,
+ },
+ };
+ return { sqlite, resources, environment };
+};
+
+const insertS3Config = async (sqlite, {
+ id = "instance-s3",
+ encryptedSecret,
+ isActive = false,
+ bucket = "edgeever-fake",
+ endpoint = "https://objects.example.test",
+} = {}) => {
+ if (isActive) sqlite.exec("UPDATE object_storage_configs SET is_active = 0");
+ sqlite.query(
+ `INSERT INTO object_storage_configs (
+ id, provider, display_name, endpoint, region, bucket, access_key_id,
+ secret_access_key_encrypted, force_path_style, object_prefix, is_active
+ ) VALUES (?, 's3', 'Fake S3', ?, 'us-east-1', ?, 'FAKE-access-key-id', ?, 1, 'notes', ?)`,
+ ).run(
+ id,
+ endpoint,
+ bucket,
+ encryptedSecret === undefined ? await encryptSecret(FAKE_SECRET, primaryKey) : encryptedSecret,
+ isActive ? 1 : 0,
+ );
+};
+
+const storedSecret = (sqlite, id = "instance-s3") => sqlite
+ .query("SELECT secret_access_key_encrypted FROM object_storage_configs WHERE id = ?")
+ .get(id).secret_access_key_encrypted;
+
+describe("object storage resolution on a migrated database", () => {
+ test("seeds built-in storage as the single active configuration", async () => {
+ const { sqlite, environment } = installation();
+
+ expect(await getActiveObjectStorageConfig(environment.storage.db)).toMatchObject({
+ id: "builtin",
+ provider: "builtin",
+ secret_access_key_encrypted: null,
+ is_active: 1,
+ });
+ expect(await getObjectStorageConfig(environment.storage.db, "instance-s3")).toBeNull();
+ // The partial unique index prevents two active configurations at once.
+ await insertS3Config(sqlite);
+ expect(() => sqlite.exec("UPDATE object_storage_configs SET is_active = 1 WHERE id = 'instance-s3'"))
+ .toThrow(/UNIQUE/);
+ sqlite.close();
+ });
+
+ test("resolves the built-in store and bucket name", async () => {
+ const { sqlite, resources, environment } = installation();
+
+ expect(await resolveObjectStorage(environment)).toEqual({
+ configId: "builtin",
+ bucketName: "edgeever-resources",
+ store: resources,
+ });
+ expect(await resolveObjectStorage({ ...environment, EDGE_EVER_R2_BUCKET_NAME: " custom-bucket " }, "builtin"))
+ .toMatchObject({ configId: "builtin", bucketName: "custom-bucket" });
+ sqlite.close();
+ });
+
+ test("routes new files to the active storage and existing files to the storage they were saved with", async () => {
+ const { sqlite, resources, environment } = installation();
+ await insertS3Config(sqlite, { isActive: true });
+ const requests = recordS3Requests();
+
+ const active = await resolveObjectStorage(environment);
+ expect(active.configId).toBe("instance-s3");
+ expect(active.bucketName).toBe("edgeever-fake");
+ expect(active.store).not.toBe(resources);
+ await active.store.put("new-file.txt", new TextEncoder().encode("new"));
+ expect(requests).toEqual([{ method: "PUT", url: "https://objects.example.test/edgeever-fake/notes/new-file.txt" }]);
+
+ const legacy = await resolveObjectStorage(environment, "builtin");
+ expect(legacy).toMatchObject({ configId: "builtin", store: resources });
+
+ // Switching back to built-in storage must not orphan files stored in S3.
+ sqlite.exec("UPDATE object_storage_configs SET is_active = 0");
+ sqlite.exec("UPDATE object_storage_configs SET is_active = 1 WHERE id = 'builtin'");
+ expect((await resolveObjectStorage(environment)).store).toBe(resources);
+ const external = await resolveObjectStorage(environment, "instance-s3");
+ expect(external.configId).toBe("instance-s3");
+ await external.store.delete("old-file.txt");
+ expect(requests.at(-1)).toEqual({
+ method: "DELETE",
+ url: "https://objects.example.test/edgeever-fake/notes/old-file.txt",
+ });
+ sqlite.close();
+ });
+
+ test("defaults the resource storage column to built-in storage for existing files", () => {
+ const { sqlite } = installation();
+ const column = sqlite.query("PRAGMA table_info(resources)").all()
+ .find((entry) => entry.name === "storage_config_id");
+
+ expect(column).toMatchObject({ notnull: 1, dflt_value: "'builtin'" });
+ sqlite.close();
+ });
+
+ test("fails with 503 when a resource points to a configuration that no longer exists", async () => {
+ const { sqlite, environment } = installation();
+
+ await expect(resolveObjectStorage(environment, "deleted-config")).rejects.toMatchObject({
+ code: "object_storage_unavailable",
+ status: 503,
+ });
+ sqlite.close();
+ });
+
+ test("fails with 503 for an incomplete external configuration", async () => {
+ const { sqlite, environment } = installation();
+ await insertS3Config(sqlite, { bucket: null });
+
+ await expect(resolveObjectStorage(environment, "instance-s3")).rejects.toMatchObject({
+ code: "object_storage_unavailable",
+ status: 503,
+ message: expect.stringContaining("incomplete"),
+ });
+ sqlite.close();
+ });
+
+ test("fails with 503 when the external credential is missing", async () => {
+ const { sqlite, environment } = installation();
+ await insertS3Config(sqlite, { encryptedSecret: null });
+
+ await expect(resolveObjectStorage(environment, "instance-s3")).rejects.toMatchObject({
+ code: "object_storage_unavailable",
+ status: 503,
+ message: expect.stringContaining("missing"),
+ });
+ sqlite.close();
+ });
+
+ for (const [label, encryptedSecret] of [
+ ["encrypted with an unknown key", null],
+ ["malformed", "v1.not-base64!.garbage"],
+ ["in an unsupported format", "v2.aaaa.bbbb"],
+ ]) {
+ test(`fails with 503 without leaking when the credential is ${label}`, async () => {
+ const { sqlite, environment } = installation({
+ env: { ...authEnvironment, EDGE_EVER_AUTH_PASSWORD_FALLBACK: "fake-old-password" },
+ });
+ const ciphertext = encryptedSecret ?? await encryptSecret(FAKE_SECRET, "fake-key-from-another-instance");
+ await insertS3Config(sqlite, { encryptedSecret: ciphertext, isActive: true });
+
+ const error = await resolveObjectStorage(environment).catch((caught) => caught);
+ expect(error).toMatchObject({ name: "AppError", code: "object_storage_unavailable", status: 503 });
+ expect(error.message).not.toContain(FAKE_SECRET);
+ expect(error.message).not.toContain(ciphertext);
+ expect(storedSecret(sqlite)).toBe(ciphertext);
+ sqlite.close();
+ });
+ }
+
+ test("re-encrypts a credential saved under the rotated-password fallback with the primary key once", async () => {
+ const environmentKeys = {
+ EDGE_EVER_AUTH_PASSWORD: "fake-new-password",
+ EDGE_EVER_AUTH_PASSWORD_FALLBACK: "fake-old-password",
+ };
+ const { sqlite, environment } = installation({ env: environmentKeys });
+ const fallbackCiphertext = await encryptSecret(FAKE_SECRET, "edgeever:object-storage:v1:fake-old-password");
+ await insertS3Config(sqlite, { encryptedSecret: fallbackCiphertext, isActive: true });
+ recordS3Requests();
+
+ expect((await resolveObjectStorage(environment)).configId).toBe("instance-s3");
+ const migrated = storedSecret(sqlite);
+ expect(migrated).not.toBe(fallbackCiphertext);
+ expect(migrated).not.toContain(FAKE_SECRET);
+ expect(await decryptSecret(migrated, resolvePrimaryObjectStorageEncryptionKey(environmentKeys)))
+ .toBe(FAKE_SECRET);
+
+ await resolveObjectStorage(environment);
+ expect(storedSecret(sqlite)).toBe(migrated);
+
+ // Once migrated, the credential no longer depends on the fallback secret.
+ const { EDGE_EVER_AUTH_PASSWORD_FALLBACK: _removed, ...withoutFallback } = environment;
+ expect((await resolveObjectStorage(withoutFallback)).configId).toBe("instance-s3");
+ sqlite.close();
+ });
+
+ test("keeps a legacy-key credential readable but unmigrated when no primary key exists", async () => {
+ const legacyEnvironment = { EDGE_EVER_STORAGE_ENCRYPTION_KEY: "fake-legacy-storage-key" };
+ const { sqlite, environment } = installation({ env: legacyEnvironment });
+ const legacyCiphertext = await encryptSecret(FAKE_SECRET, "fake-legacy-storage-key");
+ await insertS3Config(sqlite, { encryptedSecret: legacyCiphertext, isActive: true });
+
+ expect((await resolveObjectStorage(environment)).configId).toBe("instance-s3");
+ expect(storedSecret(sqlite)).toBe(legacyCiphertext);
+ sqlite.close();
+ });
+
+ test("deletes objects from the storage each resource was saved with", async () => {
+ const { sqlite, resources, environment } = installation();
+ await insertS3Config(sqlite, { isActive: true });
+ const requests = recordS3Requests();
+
+ await deleteStoredObjects(environment, [
+ { storage_config_id: "builtin", object_key: "builtin-a" },
+ { storage_config_id: "instance-s3", object_key: "s3-a" },
+ { storage_config_id: null, object_key: "builtin-b" },
+ { object_key: "builtin-c" },
+ { storage_config_id: "instance-s3", object_key: "s3-b" },
+ ]);
+
+ expect(resources.deleted).toEqual([["builtin-a", "builtin-b", "builtin-c"]]);
+ expect(requests).toEqual([
+ { method: "DELETE", url: "https://objects.example.test/edgeever-fake/notes/s3-a" },
+ { method: "DELETE", url: "https://objects.example.test/edgeever-fake/notes/s3-b" },
+ ]);
+ sqlite.close();
+ });
+
+ test("does nothing for an empty deletion and stops on an unavailable configuration", async () => {
+ const { sqlite, resources, environment } = installation();
+ const requests = recordS3Requests();
+
+ await deleteStoredObjects(environment, []);
+ expect(resources.deleted).toEqual([]);
+
+ await expect(deleteStoredObjects(environment, [
+ { storage_config_id: "deleted-config", object_key: "orphan" },
+ ])).rejects.toMatchObject({ code: "object_storage_unavailable", status: 503 });
+ expect(requests).toHaveLength(0);
+ sqlite.close();
+ });
+});
diff --git a/apps/api/src/user-routes.test.mjs b/apps/api/src/user-routes.test.mjs
index 3ffcd5af..9809f975 100644
--- a/apps/api/src/user-routes.test.mjs
+++ b/apps/api/src/user-routes.test.mjs
@@ -1,7 +1,26 @@
import { Database } from "bun:sqlite";
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
+import { globSync, readFileSync } from "node:fs";
import { Hono } from "hono";
+import { hashPassword, verifyPassword } from "./auth-crypto.ts";
+import { registerAuthRoutes } from "./auth-routes.ts";
+import {
+ authenticateRequest,
+ authenticateSession,
+ createSession,
+ getBearerToken,
+ getInstanceAuthMode,
+ getInstanceUser,
+ getLoginAttemptKeys,
+ revokeSession,
+ setSessionCookie,
+ tooManyLoginAttempts,
+ verifyLogin,
+} from "./auth-service.ts";
+import { sha256 } from "./hash-utils.ts";
+import { createSelfHostedStorageAdapter } from "./self-hosted-storage-adapter.ts";
import { registerUserRoutes } from "./user-routes.ts";
+import { ensureUserWorkspace } from "./workspace-provisioning.ts";
const ownerAuth = {
kind: "user",
@@ -138,3 +157,358 @@ describe("instance attachment storage usage", () => {
}
});
});
+
+const instances = [];
+afterEach(() => {
+ for (const sqlite of instances.splice(0)) sqlite.close();
+});
+
+// A real instance: every migration, the production auth and user routes, and
+// sessions that come from a genuine password login.
+const createInstance = async () => {
+ const sqlite = new Database(":memory:");
+ instances.push(sqlite);
+ for (const path of globSync("migrations/*.sql").sort()) sqlite.exec(readFileSync(path, "utf8"));
+ sqlite.query("INSERT INTO users (id, username, password_hash, display_name) VALUES (?, ?, ?, ?)")
+ .run("usr_owner", "owner", await hashPassword("owner-password"), "Owner");
+ sqlite.query("INSERT INTO api_tokens (id, name, token_hash, scopes_json, workspace_id) VALUES (?, ?, ?, ?, ?)")
+ .run("tok_agent", "Agent", await sha256("agent-token"), JSON.stringify(["read:memos", "write:memos"]), "ws_default");
+
+ const app = new Hono();
+ registerAuthRoutes(app, {
+ authenticateRequest,
+ authenticateSession,
+ createSession,
+ ensureUserWorkspace,
+ getBearerToken,
+ getInstanceAuthMode,
+ getLoginAttemptKeys,
+ isDemoEnvironment: () => false,
+ isDemoMode: () => false,
+ revokeSession,
+ setSessionCookie,
+ tooManyLoginAttempts,
+ verifyLogin,
+ });
+ registerUserRoutes(app, { authenticateRequest, getInstanceUser });
+ const environment = { storage: createSelfHostedStorageAdapter(sqlite, "/tmp/edgeever-user-routes-unused") };
+
+ const request = (path, { token, method = "GET", body } = {}) => app.request(path, {
+ method,
+ headers: {
+ ...(token ? { Authorization: `Bearer ${token}` } : {}),
+ ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+ },
+ body: body === undefined ? undefined : JSON.stringify(body),
+ }, environment);
+ const login = async (username, password) => {
+ const response = await request("/api/v1/auth/login", { method: "POST", body: { username, password } });
+ return { status: response.status, body: await response.json() };
+ };
+ const sessionsOf = (userId) => sqlite.query(
+ "SELECT id, revoked_at FROM sessions WHERE user_id = ? ORDER BY created_at",
+ ).all(userId);
+
+ const owner = await login("owner", "owner-password");
+ expect(owner.status).toBe(200);
+ expect(owner.body.user.role).toBe("owner");
+ return { sqlite, request, login, sessionsOf, ownerToken: owner.body.sessionToken };
+};
+
+const createMember = async (instance, input = {}) => {
+ const response = await instance.request("/api/v1/users", {
+ token: instance.ownerToken,
+ method: "POST",
+ body: { username: "writer", password: "writer-password", displayName: "Writer", ...input },
+ });
+ expect(response.status).toBe(201);
+ return (await response.json()).user;
+};
+
+describe("instance user management with a real database", () => {
+ test("lets the owner create a member with a provisioned personal workspace", async () => {
+ const instance = await createInstance();
+ const response = await instance.request("/api/v1/users", {
+ token: instance.ownerToken,
+ method: "POST",
+ body: { username: " writer ", password: "writer-password", displayName: "Writer" },
+ });
+
+ expect(response.status).toBe(201);
+ const { user } = await response.json();
+ expect(user).toEqual({
+ id: expect.stringMatching(/^usr_/),
+ username: "writer",
+ displayName: "Writer",
+ role: "member",
+ isDisabled: false,
+ lastLoginAt: null,
+ createdAt: expect.any(String),
+ });
+ expect(JSON.stringify(user)).not.toContain("password");
+
+ const stored = instance.sqlite.query("SELECT password_hash FROM users WHERE id = ?").get(user.id);
+ expect(stored.password_hash).not.toBe("writer-password");
+ expect(await verifyPassword("writer-password", stored.password_hash)).toBe(true);
+
+ const membership = instance.sqlite.query(
+ `SELECT wm.workspace_id, wm.role, w.name, w.is_personal
+ FROM workspace_members wm INNER JOIN workspaces w ON w.id = wm.workspace_id
+ WHERE wm.user_id = ?`,
+ ).all(user.id);
+ expect(membership).toEqual([{
+ workspace_id: expect.stringMatching(/^ws_/),
+ role: "member",
+ name: "Writer's workspace",
+ is_personal: 1,
+ }]);
+ const workspaceId = membership[0].workspace_id;
+ expect(workspaceId).not.toBe("ws_default");
+ expect(instance.sqlite.query("SELECT COUNT(*) AS count FROM notebooks WHERE workspace_id = ?").get(workspaceId).count)
+ .toBeGreaterThan(0);
+ expect(instance.sqlite.query("SELECT COUNT(*) AS count FROM workspace_seed_localizations WHERE workspace_id = ?")
+ .get(workspaceId).count).toBe(1);
+ expect(instance.sqlite.query("SELECT actor_id, entity_id FROM audit_events WHERE action = 'user.create'").all())
+ .toEqual([{ actor_id: "usr_owner", entity_id: user.id }]);
+
+ const memberLogin = await instance.login("writer", "writer-password");
+ expect(memberLogin.status).toBe(200);
+ expect(memberLogin.body.user).toEqual({ id: user.id, username: "writer", displayName: "Writer", role: "member" });
+
+ const listing = await instance.request("/api/v1/users", { token: instance.ownerToken });
+ expect(listing.status).toBe(200);
+ const { users } = await listing.json();
+ expect(users.map((entry) => [entry.username, entry.role])).toEqual([["owner", "owner"], ["writer", "member"]]);
+ expect(users[1].lastLoginAt).toEqual(expect.any(String));
+ expect(JSON.stringify(users)).not.toContain("password");
+ });
+
+ test("defaults the display name to the username", async () => {
+ const instance = await createInstance();
+ const user = await createMember(instance, { username: "reader", displayName: undefined });
+ expect(user.displayName).toBe("reader");
+ expect(instance.sqlite.query(
+ "SELECT w.name FROM workspaces w INNER JOIN workspace_members wm ON wm.workspace_id = w.id WHERE wm.user_id = ?",
+ ).get(user.id).name).toBe("reader's workspace");
+ });
+
+ test("rejects duplicate usernames exactly as stored, which is case-sensitive", async () => {
+ const instance = await createInstance();
+ await createMember(instance);
+
+ for (const username of ["writer", " writer ", "owner"]) {
+ const duplicate = await instance.request("/api/v1/users", {
+ token: instance.ownerToken,
+ method: "POST",
+ body: { username, password: "another-password" },
+ });
+ expect(duplicate.status).toBe(409);
+ expect(await duplicate.json()).toMatchObject({ error: { code: "username_exists" } });
+ }
+
+ // users.username is a plain UNIQUE TEXT column and the lookup is an exact
+ // match, so a case variant becomes a separate account.
+ const caseVariant = await instance.request("/api/v1/users", {
+ token: instance.ownerToken,
+ method: "POST",
+ body: { username: "Writer", password: "another-password" },
+ });
+ expect(caseVariant.status).toBe(201);
+ expect(instance.sqlite.query("SELECT username FROM users ORDER BY username").all().map((row) => row.username))
+ .toEqual(["Writer", "owner", "writer"]);
+ });
+
+ test("validates usernames and passwords before writing anything", async () => {
+ const instance = await createInstance();
+ for (const body of [
+ { username: " ", password: "long-enough" },
+ { username: "x".repeat(81), password: "long-enough" },
+ { username: "short-password", password: "1234567" },
+ { username: "huge-password", password: "x".repeat(513) },
+ { username: "long-name", password: "long-enough", displayName: "x".repeat(81) },
+ { password: "long-enough" },
+ ]) {
+ const response = await instance.request("/api/v1/users", { token: instance.ownerToken, method: "POST", body });
+ expect(response.status).toBe(400);
+ }
+ expect(instance.sqlite.query("SELECT COUNT(*) AS count FROM users").get().count).toBe(1);
+ expect(instance.sqlite.query("SELECT COUNT(*) AS count FROM workspaces").get().count).toBe(1);
+ });
+
+ test("allows only the owner's interactive session to list, create and update users", async () => {
+ const instance = await createInstance();
+ const member = await createMember(instance);
+ const memberToken = (await instance.login("writer", "writer-password")).body.sessionToken;
+
+ const attempts = [
+ ["/api/v1/users", { method: "GET" }],
+ ["/api/v1/users", { method: "POST", body: { username: "intruder", password: "intruder-password" } }],
+ [`/api/v1/users/${member.id}`, { method: "PATCH", body: { isDisabled: true } }],
+ ["/api/v1/users/usr_owner", { method: "PATCH", body: { password: "taken-over-password" } }],
+ ["/api/v1/instance/storage-usage", { method: "GET" }],
+ ];
+ for (const [path, options] of attempts) {
+ expect((await instance.request(path, { ...options })).status).toBe(401);
+ expect((await instance.request(path, { ...options, token: "not-a-session" })).status).toBe(401);
+ expect((await instance.request(path, { ...options, token: memberToken })).status).toBe(403);
+ expect((await instance.request(path, { ...options, token: "agent-token" })).status).toBe(403);
+ }
+
+ expect(instance.sqlite.query("SELECT username, is_disabled FROM users ORDER BY username").all()).toEqual([
+ { username: "owner", is_disabled: 0 },
+ { username: "writer", is_disabled: 0 },
+ ]);
+ expect((await instance.login("owner", "owner-password")).status).toBe(200);
+ });
+
+ test("does not let the owner disable the instance owner", async () => {
+ const instance = await createInstance();
+ const response = await instance.request("/api/v1/users/usr_owner", {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { isDisabled: true },
+ });
+
+ expect(response.status).toBe(400);
+ expect(await response.json()).toMatchObject({ error: { code: "bad_request" } });
+ expect(instance.sqlite.query("SELECT is_disabled FROM users WHERE id = 'usr_owner'").get().is_disabled).toBe(0);
+ expect(instance.sessionsOf("usr_owner").map((session) => session.revoked_at)).toEqual([null]);
+ expect((await instance.request("/api/v1/users", { token: instance.ownerToken })).status).toBe(200);
+ });
+
+ test("rejects unknown users and invalid updates", async () => {
+ const instance = await createInstance();
+ const missing = await instance.request("/api/v1/users/usr_missing", {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { displayName: "Ghost" },
+ });
+ expect(missing.status).toBe(404);
+
+ const member = await createMember(instance);
+ for (const body of [{}, { password: "short" }, { isDisabled: "yes" }]) {
+ const response = await instance.request(`/api/v1/users/${member.id}`, {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body,
+ });
+ expect(response.status).toBe(400);
+ }
+ });
+
+ test("renames a member without ending their sessions", async () => {
+ const instance = await createInstance();
+ const member = await createMember(instance);
+ const memberToken = (await instance.login("writer", "writer-password")).body.sessionToken;
+
+ const response = await instance.request(`/api/v1/users/${member.id}`, {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { displayName: "Senior Writer" },
+ });
+
+ expect(response.status).toBe(200);
+ expect((await response.json()).user).toMatchObject({ id: member.id, displayName: "Senior Writer", isDisabled: false });
+ expect(instance.sessionsOf(member.id).map((session) => session.revoked_at)).toEqual([null]);
+ expect((await instance.request("/api/v1/auth/sessions", { token: memberToken })).status).toBe(200);
+ });
+
+ test("resetting a member's password revokes every session of that member only", async () => {
+ const instance = await createInstance();
+ const member = await createMember(instance);
+ const memberToken = (await instance.login("writer", "writer-password")).body.sessionToken;
+
+ const response = await instance.request(`/api/v1/users/${member.id}`, {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { password: "replacement-password" },
+ });
+
+ expect(response.status).toBe(200);
+ expect(JSON.stringify(await response.json())).not.toContain("password");
+ expect(instance.sessionsOf(member.id).every((session) => session.revoked_at !== null)).toBe(true);
+ expect(instance.sessionsOf("usr_owner").map((session) => session.revoked_at)).toEqual([null]);
+ expect((await instance.request("/api/v1/auth/sessions", { token: memberToken })).status).toBe(401);
+ expect((await instance.login("writer", "writer-password")).status).toBe(401);
+ expect((await instance.login("writer", "replacement-password")).status).toBe(200);
+ expect(JSON.parse(instance.sqlite.query(
+ "SELECT metadata_json FROM audit_events WHERE action = 'user.update'",
+ ).get().metadata_json)).toEqual({ passwordReset: true });
+ });
+
+ test("resetting the owner's own password signs out the current owner session too", async () => {
+ const instance = await createInstance();
+ const response = await instance.request("/api/v1/users/usr_owner", {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { password: "new-owner-password" },
+ });
+
+ expect(response.status).toBe(200);
+ expect(instance.sessionsOf("usr_owner").every((session) => session.revoked_at !== null)).toBe(true);
+ expect((await instance.request("/api/v1/users", { token: instance.ownerToken })).status).toBe(401);
+ expect((await instance.login("owner", "new-owner-password")).body.user.role).toBe("owner");
+ });
+
+ test("disabling a member revokes their sessions and blocks login until re-enabled", async () => {
+ const instance = await createInstance();
+ const member = await createMember(instance);
+ const memberToken = (await instance.login("writer", "writer-password")).body.sessionToken;
+
+ const disabled = await instance.request(`/api/v1/users/${member.id}`, {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { isDisabled: true },
+ });
+ expect(disabled.status).toBe(200);
+ expect((await disabled.json()).user.isDisabled).toBe(true);
+ expect(instance.sessionsOf(member.id).every((session) => session.revoked_at !== null)).toBe(true);
+ expect((await instance.request("/api/v1/auth/sessions", { token: memberToken })).status).toBe(401);
+ expect((await instance.login("writer", "writer-password")).status).toBe(401);
+
+ const listed = await (await instance.request("/api/v1/users", { token: instance.ownerToken })).json();
+ expect(listed.users.find((entry) => entry.id === member.id).isDisabled).toBe(true);
+
+ const enabled = await instance.request(`/api/v1/users/${member.id}`, {
+ token: instance.ownerToken,
+ method: "PATCH",
+ body: { isDisabled: false },
+ });
+ expect(enabled.status).toBe(200);
+ expect((await enabled.json()).user.isDisabled).toBe(false);
+ // Re-enabling the account does not bring the revoked session back.
+ expect((await instance.request("/api/v1/auth/sessions", { token: memberToken })).status).toBe(401);
+ expect((await instance.login("writer", "writer-password")).status).toBe(200);
+ });
+
+ test("reports storage usage per member workspace from migrated tables", async () => {
+ const instance = await createInstance();
+ const member = await createMember(instance);
+ const memberWorkspace = instance.sqlite.query("SELECT workspace_id FROM workspace_members WHERE user_id = ?")
+ .get(member.id).workspace_id;
+ const notebookIn = (workspaceId) => instance.sqlite.query(
+ "SELECT id FROM notebooks WHERE workspace_id = ? LIMIT 1",
+ ).get(workspaceId).id;
+ const insertMemo = instance.sqlite.query("INSERT INTO memos (id, notebook_id, workspace_id) VALUES (?, ?, ?)");
+ insertMemo.run("memo_owner", notebookIn("ws_default"), "ws_default");
+ insertMemo.run("memo_member", notebookIn(memberWorkspace), memberWorkspace);
+ const insertResource = instance.sqlite.query(
+ "INSERT INTO resources (id, memo_id, object_key, kind, byte_size, is_deleted) VALUES (?, ?, ?, ?, ?, ?)",
+ );
+ insertResource.run("res_owner_image", "memo_owner", "owner/image", "image", 1000, 0);
+ insertResource.run("res_member_file", "memo_member", "member/file", "attachment", 300, 0);
+ insertResource.run("res_member_image", "memo_member", "member/image", "image", 20, 0);
+ insertResource.run("res_member_deleted", "memo_member", "member/deleted", "attachment", 5000, 1);
+
+ const response = await instance.request("/api/v1/instance/storage-usage", { token: instance.ownerToken });
+
+ expect(response.status).toBe(200);
+ const usage = await response.json();
+ expect(usage.summary).toEqual({ totalCount: 3, totalBytes: 1320, imageCount: 2, attachmentCount: 1 });
+ const byUser = Object.fromEntries(usage.users.map((entry) => [entry.userId, entry.summary]));
+ expect(byUser).toEqual({
+ [member.id]: { totalCount: 2, totalBytes: 320, imageCount: 1, attachmentCount: 1 },
+ usr_owner: { totalCount: 1, totalBytes: 1000, imageCount: 1, attachmentCount: 0 },
+ });
+ });
+});