AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
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.mjsindex 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.mjsnew file mode 100644index 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.mjsindex 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.mjsindex 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.mjsindex 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 },+ });+ });+});