feat(workspace): add shared Drive browsing editing and Worker grants
This commit is contained in:
@@ -0,0 +1,396 @@
|
||||
// Browser-only, in-memory API fixture. This is NOT Backend authorization/storage evidence.
|
||||
import type {
|
||||
DriveEntry,
|
||||
DriveEntryRef,
|
||||
DriveGrantResponse,
|
||||
DriveMutation,
|
||||
DriveMutationResponse,
|
||||
} from "../../../web/workspace/src/lib/generated/drive-api.ts";
|
||||
import { fixturePng } from "./raster.ts";
|
||||
|
||||
type Node = { entry: DriveEntry; bytes: Uint8Array };
|
||||
type Workspace = {
|
||||
nodes: Map<string, Node>;
|
||||
receipts: Map<string, DriveMutationResponse>;
|
||||
grants: DriveGrantResponse[];
|
||||
next: bigint;
|
||||
};
|
||||
export type FixtureLog = {
|
||||
workspace: string;
|
||||
path: string;
|
||||
method: string;
|
||||
requestId: string | null;
|
||||
nodeId: string | null;
|
||||
expectedRevision: string | null;
|
||||
};
|
||||
const encoder = new TextEncoder();
|
||||
const rootId = "9007199254740993";
|
||||
export const fixtureRootId = rootId;
|
||||
const instant = "2026-01-02T00:00:00Z";
|
||||
const errors = {
|
||||
denied: 403,
|
||||
not_found: 404,
|
||||
conflict: 409,
|
||||
invalid: 400,
|
||||
limit: 413,
|
||||
storage_unavailable: 503,
|
||||
outcome_unknown: 503,
|
||||
} as const;
|
||||
function failure(code: keyof typeof errors): Response {
|
||||
return Response.json({
|
||||
code,
|
||||
classification: code === "outcome_unknown" ? "unknown" : "not_committed",
|
||||
message: `Drive fixture ${code}`,
|
||||
}, { status: errors[code] });
|
||||
}
|
||||
export function createDriveFixture() {
|
||||
const workspaces = new Map<string, Workspace>();
|
||||
const log: FixtureLog[] = [];
|
||||
const faults = new Map<string, string>();
|
||||
function ws(id: string): Workspace {
|
||||
let state = workspaces.get(id);
|
||||
if (state) return state;
|
||||
state = { nodes: new Map(), receipts: new Map(), grants: [], next: 100n };
|
||||
workspaces.set(id, state);
|
||||
const add = (
|
||||
nodeId: string,
|
||||
name: string,
|
||||
kind: "folder" | "file",
|
||||
parent: string | null,
|
||||
contentType: string | null,
|
||||
bytes = new Uint8Array(),
|
||||
) => {
|
||||
const ref = (n: string): DriveEntryRef => ({ workspace_id: id, node_id: n });
|
||||
state!.nodes.set(nodeId, {
|
||||
bytes,
|
||||
entry: {
|
||||
entry: ref(nodeId),
|
||||
parent: parent === null ? null : ref(parent),
|
||||
name,
|
||||
kind,
|
||||
revision: "1",
|
||||
size: kind === "file" ? bytes.length : null,
|
||||
content_type: contentType,
|
||||
updated_by: "fixture-worker",
|
||||
updated_at: instant,
|
||||
latest_url: `/api/w/${encodeURIComponent(id)}/drive/${
|
||||
kind === "file" ? "download" : "metadata"
|
||||
}?entry_workspace_id=${encodeURIComponent(id)}&id=${nodeId}`,
|
||||
},
|
||||
});
|
||||
};
|
||||
add(rootId, "Drive", "folder", null, null);
|
||||
if (id.includes("empty")) return state;
|
||||
add("2", "資料", "folder", rootId, null);
|
||||
add(
|
||||
"3",
|
||||
"README.md",
|
||||
"file",
|
||||
rootId,
|
||||
"text/markdown",
|
||||
encoder.encode(
|
||||
`# Shared notes\n\nWorker-created latest-only document.\n\n[Local folder](/w/${
|
||||
encodeURIComponent(id)
|
||||
}/drive/2)\n\n[Unsafe](javascript:alert(1))\n\n<img src=x onerror=alert(1)>\n\n\n\n
|
||||
}/drive/5)\n`,
|
||||
),
|
||||
);
|
||||
add("4", "notes.txt", "file", "2", "text/plain", encoder.encode("Second document — 日本語"));
|
||||
add("5", "landscape.png", "file", rootId, "image/png", fixturePng);
|
||||
add("6", "empty.txt", "file", rootId, "text/plain");
|
||||
add("7", "broken.png", "file", rootId, "image/png", encoder.encode("not a valid PNG"));
|
||||
add(
|
||||
"8",
|
||||
"unsafe.svg",
|
||||
"file",
|
||||
rootId,
|
||||
"image/svg+xml",
|
||||
encoder.encode('<svg onload="alert(1)"></svg>'),
|
||||
);
|
||||
add(
|
||||
"9",
|
||||
"large.txt",
|
||||
"file",
|
||||
rootId,
|
||||
"text/plain",
|
||||
encoder.encode("bounded preview\n".repeat(5000)),
|
||||
);
|
||||
add(
|
||||
"10",
|
||||
"長い名前 — 国際化された資料と分散開発の成果物 — ".repeat(2) + ".md",
|
||||
"file",
|
||||
rootId,
|
||||
"text/markdown",
|
||||
encoder.encode("# Long name"),
|
||||
);
|
||||
add("11", "escaped-64k.txt", "file", rootId, "text/plain", new Uint8Array(65536));
|
||||
if (id.includes("paged")) {
|
||||
for (let n = 20; n < 260; n++) {
|
||||
add(
|
||||
String(n),
|
||||
`Document ${n}.txt`,
|
||||
"file",
|
||||
rootId,
|
||||
"text/plain",
|
||||
encoder.encode(String(n)),
|
||||
);
|
||||
}
|
||||
}
|
||||
state.next = id.includes("paged") ? 300n : 100n;
|
||||
return state;
|
||||
}
|
||||
function bump(node: Node) {
|
||||
node.entry.revision = String(BigInt(node.entry.revision) + 1n);
|
||||
}
|
||||
function mutate(id: string, mutation: DriveMutation): DriveEntry | null {
|
||||
const state = ws(id);
|
||||
const target = "id" in mutation ? state.nodes.get(mutation.id.node_id) : null;
|
||||
if ("id" in mutation && (mutation.id.workspace_id !== id || !target)) throw "not_found";
|
||||
if (
|
||||
target && "expected_revision" in mutation &&
|
||||
target.entry.revision !== mutation.expected_revision
|
||||
) throw "conflict";
|
||||
if ("parent" in mutation) {
|
||||
const parent = state.nodes.get(mutation.parent.node_id);
|
||||
if (mutation.parent.workspace_id !== id || parent?.entry.kind !== "folder") throw "not_found";
|
||||
}
|
||||
if ("name" in mutation) {
|
||||
if (
|
||||
!mutation.name || mutation.name.includes("/") || encoder.encode(mutation.name).length > 255
|
||||
) throw "invalid";
|
||||
if (
|
||||
[...state.nodes.values()].some((n) =>
|
||||
n !== target && n.entry.parent?.node_id === mutation.parent.node_id &&
|
||||
n.entry.name === mutation.name
|
||||
)
|
||||
) throw "conflict";
|
||||
}
|
||||
if (mutation.operation === "delete") {
|
||||
if (
|
||||
target!.entry.parent === null ||
|
||||
[...state.nodes.values()].some((n) => n.entry.parent?.node_id === mutation.id.node_id)
|
||||
) throw "conflict";
|
||||
state.nodes.delete(mutation.id.node_id);
|
||||
return null;
|
||||
}
|
||||
if (mutation.operation === "relocate") {
|
||||
target!.entry.parent = mutation.parent;
|
||||
target!.entry.name = mutation.name;
|
||||
bump(target!);
|
||||
return target!.entry;
|
||||
}
|
||||
if (mutation.operation === "update_text") {
|
||||
target!.bytes = encoder.encode(mutation.text);
|
||||
target!.entry.size = target!.bytes.length;
|
||||
target!.entry.content_type = mutation.content_type;
|
||||
bump(target!);
|
||||
return target!.entry;
|
||||
}
|
||||
const nodeId = String(state.next++);
|
||||
const bytes = mutation.operation === "create_text"
|
||||
? encoder.encode(mutation.text)
|
||||
: new Uint8Array();
|
||||
const entry: DriveEntry = {
|
||||
entry: { workspace_id: id, node_id: nodeId },
|
||||
parent: mutation.parent,
|
||||
name: mutation.name,
|
||||
kind: mutation.operation === "create_folder" ? "folder" : "file",
|
||||
revision: "1",
|
||||
size: mutation.operation === "create_folder" ? null : bytes.length,
|
||||
content_type: mutation.operation === "create_text" ? mutation.content_type : null,
|
||||
updated_by: "fixture-user",
|
||||
updated_at: instant,
|
||||
latest_url: `/api/w/${encodeURIComponent(id)}/drive/${
|
||||
mutation.operation === "create_folder" ? "metadata" : "download"
|
||||
}?entry_workspace_id=${encodeURIComponent(id)}&id=${nodeId}`,
|
||||
};
|
||||
state.nodes.set(nodeId, { entry, bytes });
|
||||
return entry;
|
||||
}
|
||||
async function handler(request: Request): Promise<Response | null> {
|
||||
const url = new URL(request.url);
|
||||
if (url.pathname === "/__fixture/log") return Response.json(log);
|
||||
if (url.pathname === "/__fixture/reset" && request.method === "POST") {
|
||||
workspaces.clear();
|
||||
faults.clear();
|
||||
log.length = 0;
|
||||
return Response.json({ ok: true });
|
||||
}
|
||||
if (url.pathname === "/__fixture/fault" && request.method === "POST") {
|
||||
const body = await request.json();
|
||||
faults.set(body.workspace, body.mode);
|
||||
return Response.json({ ok: true });
|
||||
}
|
||||
const match = url.pathname.match(/^\/api\/w\/([^/]+)\/drive(\/.*)$/);
|
||||
if (!match) return null;
|
||||
const id = decodeURIComponent(match[1]), path = match[2];
|
||||
const state = ws(id);
|
||||
const mutationRoute = path === "/mutate" || path === "/upload";
|
||||
const event: FixtureLog = {
|
||||
workspace: id,
|
||||
path,
|
||||
method: request.method,
|
||||
requestId: url.searchParams.get("request_id"),
|
||||
nodeId: url.searchParams.get("id") ?? url.searchParams.get("parent_id"),
|
||||
expectedRevision: url.searchParams.get("expected_revision"),
|
||||
};
|
||||
log.push(event);
|
||||
if (id.includes("denied")) return failure("denied");
|
||||
if (id.includes("offline") || id === "home-error") return failure("storage_unavailable");
|
||||
if (mutationRoute && (id.includes("readonly") || id === "home-member")) {
|
||||
return failure("denied");
|
||||
}
|
||||
if (path.startsWith("/requests/")) {
|
||||
const requestId = decodeURIComponent(path.slice(10));
|
||||
const response = state.receipts.get(requestId) ?? null;
|
||||
return Response.json({
|
||||
request_id: requestId,
|
||||
state: response ? "committed" : "uncommitted",
|
||||
response,
|
||||
});
|
||||
}
|
||||
if (path === "/grants") {
|
||||
if (id === "home-member") return failure("denied");
|
||||
if (request.method === "POST") {
|
||||
const input = await request.json();
|
||||
const grant: DriveGrantResponse = {
|
||||
...input,
|
||||
grant_id: String(state.grants.length + 1),
|
||||
workspace_id: id,
|
||||
revoked: false,
|
||||
created_by: "fixture-owner",
|
||||
created_at: instant,
|
||||
revoked_by: null,
|
||||
revoked_at: null,
|
||||
};
|
||||
state.grants.push(grant);
|
||||
return Response.json(grant);
|
||||
}
|
||||
return Response.json({ grants: state.grants, next_after: null });
|
||||
}
|
||||
if (/^\/grants\/\d+$/.test(path) && request.method === "DELETE") {
|
||||
if (id === "home-member") return failure("denied");
|
||||
const grant = state.grants.find((g) => g.grant_id === path.split("/")[2]);
|
||||
if (!grant) return failure("not_found");
|
||||
grant.revoked = true;
|
||||
grant.revoked_at = instant;
|
||||
grant.revoked_by = "fixture-owner";
|
||||
return Response.json(grant);
|
||||
}
|
||||
if (mutationRoute) {
|
||||
try {
|
||||
const payload = path === "/mutate" ? await request.json() : null;
|
||||
const requestId = path === "/upload"
|
||||
? url.searchParams.get("request_id")!
|
||||
: payload.request_id;
|
||||
event.requestId = requestId;
|
||||
if (payload) {
|
||||
event.nodeId = payload.mutation.id?.node_id ?? payload.mutation.parent?.node_id ?? null;
|
||||
event.expectedRevision = payload.mutation.expected_revision ?? null;
|
||||
}
|
||||
if (state.receipts.has(requestId)) return Response.json(state.receipts.get(requestId));
|
||||
const fault = faults.get(id);
|
||||
if (fault === "conflict") {
|
||||
faults.delete(id);
|
||||
return failure("conflict");
|
||||
}
|
||||
let entry: DriveEntry | null;
|
||||
if (path === "/mutate") entry = mutate(id, payload.mutation);
|
||||
else {
|
||||
const bytes = new Uint8Array(await request.arrayBuffer());
|
||||
if (bytes.length > 16 * 1024 * 1024) return failure("limit");
|
||||
if (bytes.length !== Number(url.searchParams.get("size"))) return failure("invalid");
|
||||
const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
|
||||
if (
|
||||
[...digest].map((n) => n.toString(16).padStart(2, "0")).join("") !==
|
||||
url.searchParams.get("sha256")
|
||||
) return failure("invalid");
|
||||
const content_type = url.searchParams.get("content_type")!;
|
||||
if (url.searchParams.get("operation") === "create") {
|
||||
entry = mutate(id, {
|
||||
operation: "create_text",
|
||||
parent: { workspace_id: id, node_id: url.searchParams.get("parent_id")! },
|
||||
name: url.searchParams.get("name")!,
|
||||
text: "",
|
||||
content_type,
|
||||
});
|
||||
} else {entry = mutate(id, {
|
||||
operation: "update_text",
|
||||
id: { workspace_id: id, node_id: url.searchParams.get("id")! },
|
||||
expected_revision: url.searchParams.get("expected_revision")!,
|
||||
text: "",
|
||||
content_type,
|
||||
});}
|
||||
const node = state.nodes.get(entry!.entry.node_id)!;
|
||||
node.bytes = bytes;
|
||||
node.entry.size = bytes.length;
|
||||
}
|
||||
const response = structuredClone({ request_id: requestId, entry });
|
||||
state.receipts.set(requestId, response);
|
||||
if (fault === "unknown") {
|
||||
faults.delete(id);
|
||||
return failure("outcome_unknown");
|
||||
}
|
||||
return Response.json(response);
|
||||
} catch (error) {
|
||||
return failure(
|
||||
typeof error === "string" && error in errors ? error as keyof typeof errors : "invalid",
|
||||
);
|
||||
}
|
||||
}
|
||||
const nodeId = path === "/root" ? rootId : url.searchParams.get("id");
|
||||
if (nodeId !== null && path !== "/root" && url.searchParams.get("entry_workspace_id") !== id) {
|
||||
return failure("invalid");
|
||||
}
|
||||
const node = nodeId ? state.nodes.get(nodeId) : null;
|
||||
if (path === "/root" || path === "/metadata") {
|
||||
return node ? Response.json(node.entry) : failure("not_found");
|
||||
}
|
||||
if (path === "/list" || path === "/search") {
|
||||
if (path === "/list" && node?.entry.kind !== "folder") return failure("not_found");
|
||||
const all = [...state.nodes.values()].filter((n) =>
|
||||
path === "/search"
|
||||
? n.entry.name.includes(url.searchParams.get("query") ?? "")
|
||||
: n.entry.parent?.node_id === nodeId
|
||||
).sort((a, b) => a.entry.name.localeCompare(b.entry.name));
|
||||
const after = url.searchParams.get("after");
|
||||
const start = after ? all.findIndex((n) => n.entry.entry.node_id === after) + 1 : 0;
|
||||
const limit = Math.min(Number(url.searchParams.get("limit") ?? 50), 200);
|
||||
const entries = all.slice(start, start + limit).map((n) => n.entry);
|
||||
return Response.json({
|
||||
entries,
|
||||
next_after: start + limit < all.length ? entries.at(-1)!.entry.node_id : null,
|
||||
});
|
||||
}
|
||||
if (!node || node.entry.kind !== "file") return failure("not_found");
|
||||
if (path === "/read-text") {
|
||||
const text = new TextDecoder().decode(node.bytes.slice(0, 65536));
|
||||
return Response.json({ entry: node.entry, text, truncated: node.bytes.length > 65536 });
|
||||
}
|
||||
if (path === "/download" || path === "/read-chunk") {
|
||||
if (
|
||||
url.searchParams.has("expected_revision") &&
|
||||
url.searchParams.get("expected_revision") !== node.entry.revision
|
||||
) return failure("conflict");
|
||||
if (faults.get(id) === "image_error" && node.entry.content_type?.startsWith("image/")) {
|
||||
return failure("storage_unavailable");
|
||||
}
|
||||
const bytes = path === "/read-chunk"
|
||||
? node.bytes.slice(
|
||||
Number(url.searchParams.get("offset")),
|
||||
Number(url.searchParams.get("offset")) + Number(url.searchParams.get("length")),
|
||||
)
|
||||
: node.bytes;
|
||||
return new Response(new Uint8Array(bytes).buffer, {
|
||||
headers: {
|
||||
"content-type": node.entry.content_type!,
|
||||
"content-disposition": "attachment",
|
||||
"x-content-type-options": "nosniff",
|
||||
},
|
||||
});
|
||||
}
|
||||
return failure("not_found");
|
||||
}
|
||||
return { handler, log };
|
||||
}
|
||||
Reference in New Issue
Block a user