@goodfellow-cms/gitlab 0.1.0 → 0.3.0

package/dist/testing.js

@@ -24,14 +24,319 @@ function fakeGitLab(options) {
 		username: "editor",
 		name: "Test Editor"
 	} }));
+	let nextUserId = 1;
+	/** Every GitLab account, by username, with its id. */
+	const accounts = /* @__PURE__ */ new Map();
+	for (const name of [...[...tokens.values(), ...options.oauth ? [options.oauth.user] : []].map((user) => user.username), ...options.accounts ?? []]) if (!accounts.has(name)) accounts.set(name, nextUserId++);
+	const members = /* @__PURE__ */ new Map();
+	for (const user of [...tokens.values(), ...options.oauth ? [options.oauth.user] : []]) {
+		const id = accounts.get(user.username) ?? 0;
+		members.set(id, {
+			id,
+			username: user.username,
+			name: user.name,
+			accessLevel: user.accessLevel ?? 40
+		});
+	}
+	const invitations = /* @__PURE__ */ new Map();
+	/** Protected branches and who may push to them: GitLab protects the default branch for Maintainers. */
+	const protectedBranches = /* @__PURE__ */ new Map([[repo.defaultBranch, {
+		push: 40,
+		merge: 40,
+		forcePush: false
+	}]]);
+	/** The project's members and invitations, and its protected branches. */
+	async function handleMembers(request, url, rest, accessLevel) {
+		const forbidden = () => json({ message: "403 Forbidden" }, 403);
+		const list = (items) => {
+			const perPage = Number(url.searchParams.get("per_page") ?? 20);
+			const page = Number(url.searchParams.get("page") ?? 1);
+			return json(items.slice((page - 1) * perPage, page * perPage));
+		};
+		const shown = (member) => ({
+			id: member.id,
+			username: member.username,
+			name: member.name ?? member.username,
+			avatar_url: `https://avatars.example/${member.username}`,
+			access_level: member.accessLevel
+		});
+		if (rest === "/members/all" && request.method === "GET") return list([...members.values()].map(shown));
+		if (rest === "/members" && request.method === "GET") return list([...members.values()].filter((member) => !member.inherited).map(shown));
+		if (rest === "/members" && request.method === "POST") {
+			if (accessLevel < 40) return forbidden();
+			const body = await request.json();
+			const username = [...accounts].find(([, id]) => id === body.user_id)?.[0];
+			if (!username) return json({ message: "404 User Not Found" }, 404);
+			if (members.has(body.user_id)) return json({ message: "Member already exists" }, 409);
+			members.set(body.user_id, {
+				id: body.user_id,
+				username,
+				accessLevel: body.access_level
+			});
+			return json(shown(members.get(body.user_id)), 201);
+		}
+		const member = rest.match(/^\/members\/(\d+)$/);
+		if (member) {
+			if (accessLevel < 40) return forbidden();
+			const found = members.get(Number(member[1]));
+			if (!found || found.inherited) return json({ message: "404 Member Not Found" }, 404);
+			if (request.method === "DELETE") {
+				members.delete(found.id);
+				return new Response(null, { status: 204 });
+			}
+			if (request.method === "PUT") {
+				found.accessLevel = (await request.json()).access_level;
+				return json(shown(found));
+			}
+		}
+		if (rest === "/invitations") {
+			if (accessLevel < 40) return forbidden();
+			if (request.method === "GET") return list([...invitations].map(([email, level]) => ({
+				invite_email: email,
+				access_level: level
+			})));
+			if (request.method === "POST") {
+				const body = await request.json();
+				if (invitations.has(body.email)) return json({
+					status: "error",
+					message: { [body.email]: "Invite email has already been taken" }
+				}, 201);
+				invitations.set(body.email, body.access_level);
+				return json({ status: "success" }, 201);
+			}
+		}
+		const invitation = rest.match(/^\/invitations\/([^/]+)$/);
+		if (invitation) {
+			if (accessLevel < 40) return forbidden();
+			const email = decodeURIComponent(invitation[1] ?? "");
+			if (!invitations.has(email)) return json({ message: "404 Not Found" }, 404);
+			if (request.method === "DELETE") {
+				invitations.delete(email);
+				return new Response(null, { status: 204 });
+			}
+			if (request.method === "PUT") {
+				invitations.set(email, (await request.json()).access_level);
+				return json({ invite_email: email });
+			}
+		}
+		const protection = rest.match(/^\/protected_branches\/([^/]+)$/);
+		if (protection) {
+			const name = decodeURIComponent(protection[1] ?? "");
+			const found = protectedBranches.get(name);
+			if (!found) return json({ message: "404 Not found" }, 404);
+			if (request.method === "GET") return json({
+				name,
+				push_access_levels: [{ access_level: found.push }],
+				merge_access_levels: [{ access_level: found.merge }],
+				allow_force_push: found.forcePush
+			});
+			if (request.method === "DELETE") {
+				if (accessLevel < 40) return forbidden();
+				protectedBranches.delete(name);
+				return new Response(null, { status: 204 });
+			}
+		}
+		if (rest === "/protected_branches" && request.method === "POST") {
+			if (accessLevel < 40) return forbidden();
+			const body = await request.json();
+			if (protectedBranches.has(body.name)) return json({ message: "Protected branch already exists" }, 409);
+			protectedBranches.set(body.name, {
+				push: body.push_access_level ?? 40,
+				merge: body.merge_access_level ?? 40,
+				forcePush: body.allow_force_push ?? false
+			});
+			return json({ name: body.name }, 201);
+		}
+	}
 	const codes = /* @__PURE__ */ new Map();
 	const refreshTokens = /* @__PURE__ */ new Map();
 	const pipelines = /* @__PURE__ */ new Map();
+	/** The project's settings for updates: whether job tokens may push, and its pipeline schedules. */
+	const updateSettings = {
+		jobTokenPush: false,
+		schedules: []
+	};
+	/** Pipelines the update ran in: scheduled, or started through the API, with the pages job's log. */
+	const updateRuns = [];
+	/** Simulates a scheduled (or API) pipeline whose pages job logged `trace`. */
+	function addUpdateRun(run) {
+		const added = {
+			id: 1e3 + updateRuns.length,
+			source: "schedule",
+			status: "success",
+			trace: "",
+			...run
+		};
+		updateRuns.push(added);
+		return added;
+	}
+	/** Failed jobs, by commit, which tests add with `failBuild()`. */
+	const failures = /* @__PURE__ */ new Map();
+	/**
+	* Simulates the pipeline for a commit failing: its `pages` job (or another,
+	* such as `pages:deploy`) fails for a GitLab failure reason, with a log.
+	*/
+	function failBuild(sha, failure = {}) {
+		if (!pipelines.has(sha)) pipelines.set(sha, { checks: 0 });
+		failures.set(sha, {
+			job: failure.job ?? "pages",
+			failureReason: failure.failureReason ?? "script_failure",
+			trace: failure.trace ?? ""
+		});
+	}
+	const pipelineId = (sha) => [...pipelines.keys()].indexOf(sha) + 1;
 	const requests = [];
 	let counter = 0;
-	function commit(changes, message) {
-		const sha = repo.commit(changes, message);
-		if (options.deployAfterChecks !== void 0) pipelines.set(sha, { checks: 0 });
+	let graphqlReads = 0;
+	const created = /* @__PURE__ */ new Map();
+	const pages = options.pages ? {
+		uniqueDomain: options.pages.uniqueDomain ?? true,
+		forceHttps: true,
+		primaryDomain: null,
+		domains: /* @__PURE__ */ new Map(),
+		dnsReady: /* @__PURE__ */ new Set()
+	} : void 0;
+	function pagesUrl() {
+		const [namespace = "", ...rest] = options.project.split("/");
+		return pages?.uniqueDomain ? `https://${rest.join("-")}-1a2b3c.gitlab.io` : `https://${namespace}.gitlab.io/${rest.join("/")}`;
+	}
+	/** GitLab Pages' settings and custom domains, for the site's own project. */
+	async function handlePages(request, rest, accessLevel) {
+		if (!rest.startsWith("/pages")) return void 0;
+		if (!pages) return json({ message: "404 Not Found" }, 404);
+		if (accessLevel < 40) return json({ message: "403 Forbidden" }, 403);
+		const method = request.method;
+		const domainJson = (name, domain) => ({
+			domain: name,
+			url: `https://${name}`,
+			verified: domain.verified,
+			verification_code: domain.verificationCode,
+			auto_ssl_enabled: true,
+			certificate: domain.certificate ? {
+				subject: `/CN=${name}`,
+				expired: false
+			} : null
+		});
+		if (rest === "/pages" && method === "GET") return json({
+			url: pagesUrl(),
+			is_unique_domain_enabled: pages.uniqueDomain,
+			force_https: pages.forceHttps,
+			primary_domain: pages.primaryDomain
+		});
+		if (rest === "/pages" && method === "PATCH") {
+			const body = await request.json();
+			if (body.pages_primary_domain !== void 0 && !pages.domains.has(body.pages_primary_domain)) return json({ message: "Primary domain must be one of the project's domains" }, 400);
+			if (body.pages_unique_domain_enabled !== void 0) pages.uniqueDomain = body.pages_unique_domain_enabled;
+			if (body.pages_https_only !== void 0) pages.forceHttps = body.pages_https_only;
+			if (body.pages_primary_domain !== void 0) pages.primaryDomain = body.pages_primary_domain;
+			return json({
+				url: pagesUrl(),
+				is_unique_domain_enabled: pages.uniqueDomain,
+				force_https: pages.forceHttps
+			});
+		}
+		if (rest === "/pages/domains" && method === "GET") return json([...pages.domains].map(([name, domain]) => domainJson(name, domain)));
+		if (rest === "/pages/domains" && method === "POST") {
+			const body = await request.json();
+			if (pages.domains.has(body.domain)) return json({ message: { domain: ["has already been taken"] } }, 400);
+			if (!/^[a-z0-9.-]+\.[a-z]+$/.test(body.domain)) return json({ message: { domain: ["is invalid"] } }, 400);
+			counter += 1;
+			const domain = {
+				verified: false,
+				verificationCode: `code-${counter}`,
+				certificate: false
+			};
+			pages.domains.set(body.domain, domain);
+			return json(domainJson(body.domain, domain), 201);
+		}
+		const one = rest.match(/^\/pages\/domains\/([^/]+)(\/verify)?$/);
+		const name = decodeURIComponent(one?.[1] ?? "");
+		const domain = pages.domains.get(name);
+		if (!one || !domain) return json({ message: "404 Not Found" }, 404);
+		if (one[2] && method === "PUT") {
+			if (!pages.dnsReady.has(name)) return json({ message: "Failed to verify domain ownership" }, 400);
+			domain.verified = true;
+			return json(domainJson(name, domain));
+		}
+		if (method === "GET") return json(domainJson(name, domain));
+		if (method === "DELETE") {
+			pages.domains.delete(name);
+			if (pages.primaryDomain === name) pages.primaryDomain = null;
+			return new Response(null, { status: 204 });
+		}
+		return json({ message: "404 Not Found" }, 404);
+	}
+	const groups = (options.groups ?? []).map((group, index) => ({
+		id: 100 + index,
+		path: group
+	}));
+	/** Creating projects, and committing to the projects created, as the setup page does. */
+	async function handleCreated(request, path, user) {
+		if (path === "/namespaces") return json([{
+			id: 1,
+			kind: "user",
+			full_path: user.username,
+			name: user.name ?? user.username
+		}, ...groups.map((group) => ({
+			id: group.id,
+			kind: "group",
+			full_path: group.path,
+			name: group.path
+		}))]);
+		if (path === "/projects" && request.method === "POST") {
+			const body = await request.json();
+			const namespace = body.namespace_id === void 0 || body.namespace_id === 1 ? user.username : groups.find((group) => group.id === body.namespace_id)?.path;
+			if (!namespace) return json({ message: "404 Namespace Not Found" }, 404);
+			if (!/^[\w.-]+$/.test(body.path)) return json({ message: { path: ["is invalid"] } }, 400);
+			const fullPath = `${namespace}/${body.path}`;
+			if (created.has(fullPath) || fullPath === options.project) return json({ message: { name: ["has already been taken"] } }, 400);
+			counter += 1;
+			const project = {
+				id: 1e3 + counter,
+				path: fullPath,
+				visibility: body.visibility,
+				description: body.description,
+				pagesAccessLevel: body.pages_access_level,
+				repo: new FakeRepo({})
+			};
+			created.set(fullPath, project);
+			return json({
+				id: project.id,
+				path_with_namespace: fullPath,
+				web_url: `${webUrl}/${fullPath}`
+			}, 201);
+		}
+		const match = path.match(/^\/projects\/([^/]+)(\/.*)?$/);
+		const key = decodeURIComponent(match?.[1] ?? "");
+		const project = created.get(key) ?? [...created.values()].find((candidate) => String(candidate.id) === key);
+		if (!match || !project) return void 0;
+		const rest = match[2] ?? "";
+		if (rest === "") return json({
+			id: project.id,
+			path_with_namespace: project.path,
+			default_branch: "main"
+		});
+		if (rest === "/repository/commits" && request.method === "POST") {
+			const body = await request.json();
+			return json({
+				id: project.repo.commit(body.actions.map((action) => action.encoding === "base64" ? {
+					path: action.file_path,
+					bytes: decodeBase64(action.content ?? "")
+				} : {
+					path: action.file_path,
+					content: action.content ?? ""
+				}), body.commit_message, { branch: body.branch }),
+				message: body.commit_message
+			}, 201);
+		}
+		return json({ message: "404 Not Found" }, 404);
+	}
+	function commit(changes, message, author, branch = repo.defaultBranch) {
+		const sha = repo.commit(changes, message, {
+			author,
+			branch
+		});
+		if (options.deployAfterChecks !== void 0 && branch === repo.defaultBranch) pipelines.set(sha, { checks: 0 });
 		return sha;
 	}
 	function issueTokens(user) {
@@ -89,6 +394,22 @@ function fakeGitLab(options) {
 			}
 			return json({ error: "unsupported_grant_type" }, 400);
 		}
+		if (url.pathname === "/api/graphql" && request.method === "POST") {
+			if (!tokens.has(request.headers.get("authorization")?.replace(/^Bearer /, "") ?? "")) return json({ message: "401 Unauthorized" }, 401);
+			const { variables } = await request.json();
+			if (variables.project !== options.project) return json({ data: { project: null } });
+			graphqlReads += 1;
+			const files = repo.files(variables.ref);
+			return json({ data: { project: { repository: { blobs: { nodes: variables.paths.flatMap((path) => {
+				const content = files.get(path);
+				if (content === void 0) return [];
+				return [{
+					path,
+					rawTextBlob: typeof content === "string" ? content : null,
+					size: String(fakeFileBytes(content).length)
+				}];
+			}) } } } } });
+		}
 		if (!url.pathname.startsWith("/api/v4/")) return json({ message: "404 Not Found" }, 404);
 		const user = tokens.get(request.headers.get("authorization")?.replace(/^Bearer /, "") ?? "");
 		if (!user) return json({ message: "401 Unauthorized" }, 401);
@@ -98,22 +419,89 @@ function fakeGitLab(options) {
 			name: user.name,
 			avatar_url: `https://avatars.example/${user.username}`
 		});
+		const setup = await handleCreated(request, path, user);
+		if (setup) return setup;
+		if (path === "/projects" && request.method === "GET") {
+			const level = members.get(accounts.get(user.username) ?? 0)?.accessLevel ?? 0;
+			const min = Number(url.searchParams.get("min_access_level") ?? "0");
+			return json(level > 0 && level >= min ? [{
+				path_with_namespace: options.project,
+				default_branch: repo.defaultBranch
+			}] : []);
+		}
+		if (path === "/users") {
+			const name = url.searchParams.get("username") ?? "";
+			const id = [...accounts].find(([username]) => username.toLowerCase() === name.toLowerCase())?.[1];
+			return json(id === void 0 ? [] : [{
+				id,
+				username: name
+			}]);
+		}
 		const projectMatch = path.match(/^\/projects\/([^/]+)(\/.*)?$/);
 		if (!projectMatch || decodeURIComponent(projectMatch[1] ?? "") !== options.project) return json({ message: "404 Project Not Found" }, 404);
 		const rest = projectMatch[2] ?? "";
-		const accessLevel = user.accessLevel ?? 40;
-		if (rest === "") return json({
+		const accessLevel = members.get(accounts.get(user.username) ?? 0)?.accessLevel ?? 0;
+		const pagesResponse = await handlePages(request, rest, accessLevel);
+		if (pagesResponse) return pagesResponse;
+		const membersResponse = await handleMembers(request, url, rest, accessLevel);
+		if (membersResponse) return membersResponse;
+		if (rest === "" && request.method !== "PUT") return json({
 			default_branch: repo.defaultBranch,
 			permissions: {
 				project_access: { access_level: accessLevel },
 				group_access: null
-			}
+			},
+			ci_push_repository_for_job_token_allowed: updateSettings.jobTokenPush
 		});
+		if (rest === "/repository/branches" && request.method === "POST") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const name = url.searchParams.get("branch") ?? "";
+			const ref = url.searchParams.get("ref") ?? "";
+			if (repo.branches.has(name)) return json({ message: "Branch already exists" }, 400);
+			const sha = repo.branches.get(ref) ?? (repo.commitAt(ref) ? ref : void 0);
+			if (!sha) return json({ message: "Invalid reference name" }, 400);
+			repo.branches.set(name, sha);
+			return json({
+				name,
+				commit: { id: sha }
+			}, 201);
+		}
 		const branch = rest.match(/^\/repository\/branches\/(.+)$/);
+		if (branch && request.method === "DELETE") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const name = decodeURIComponent(branch[1] ?? "");
+			if (!repo.branches.has(name)) return json({ message: "404 Branch Not Found" }, 404);
+			repo.branches.delete(name);
+			return new Response(null, { status: 204 });
+		}
 		if (branch) {
 			const sha = repo.branches.get(decodeURIComponent(branch[1] ?? ""));
 			return sha ? json({ commit: { id: sha } }) : json({ message: "404 Branch Not Found" }, 404);
 		}
+		if (rest === "/repository/merge_base") {
+			const refs = url.searchParams.getAll("refs[]").map((ref) => repo.branches.get(ref) ?? ref);
+			if (refs.length !== 2 || refs.some((ref) => !repo.commitAt(ref))) return json({ message: "Could not find ref" }, 400);
+			const base = repo.mergeBase(refs[0] ?? "", refs[1] ?? "");
+			return base ? json({ id: base }) : json({ message: "404 Not Found" }, 404);
+		}
+		if (rest === "/merge_requests" && request.method === "POST") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const body = await request.json();
+			if (!repo.branches.has(body.source_branch) || !repo.branches.has(body.target_branch)) return json({ message: ["Source branch does not exist"] }, 422);
+			if (repo.reviews.some((review) => review.branch === body.source_branch && review.state === "open")) return json({ message: ["Another open merge request already exists for this source branch"] }, 409);
+			const review = repo.openReview(body.source_branch, body.title, body.description ?? "", body.target_branch);
+			return json({
+				iid: review.number,
+				web_url: `${webUrl}/${options.project}/-/merge_requests/${review.number}`
+			}, 201);
+		}
+		if (rest === "/merge_requests" && request.method === "GET") {
+			const source = url.searchParams.get("source_branch");
+			return json(repo.reviews.filter((review) => review.state === "open" && (!source || review.branch === source)).map((review) => ({
+				iid: review.number,
+				web_url: `${webUrl}/${options.project}/-/merge_requests/${review.number}`
+			})));
+		}
 		if (rest === "/repository/tree") {
 			const ref = url.searchParams.get("ref") ?? repo.defaultBranch;
 			const dir = url.searchParams.get("path") ?? "";
@@ -133,6 +521,13 @@ function fakeGitLab(options) {
 			const content = repo.blobs.get(blob[1] ?? "");
 			return content === void 0 ? json({ message: "404 Blob Not Found" }, 404) : new Response(fakeFileBytes(content));
 		}
+		const raw = rest.match(/^\/repository\/files\/([^/]+)\/raw$/);
+		if (raw) {
+			const ref = url.searchParams.get("ref") ?? repo.defaultBranch;
+			if (!repo.commitAt(repo.branches.get(ref) ?? ref)) return json({ message: "404 Commit Not Found" }, 404);
+			const content = repo.files(ref).get(decodeURIComponent(raw[1] ?? ""));
+			return content === void 0 ? json({ message: "404 File Not Found" }, 404) : new Response(fakeFileBytes(content));
+		}
 		const file = rest.match(/^\/repository\/files\/([^/]+)$/);
 		if (file) {
 			const filePath = decodeURIComponent(file[1] ?? "");
@@ -145,6 +540,8 @@ function fakeGitLab(options) {
 		}
 		if (rest === "/repository/commits" && request.method === "POST") {
 			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const pushTo = await request.clone().json();
+			if (accessLevel < (protectedBranches.get(pushTo.branch)?.push ?? 0)) return json({ message: "You are not allowed to push into this branch" }, 403);
 			const body = await request.json();
 			const files = repo.files(body.branch);
 			for (const action of body.actions) {
@@ -162,10 +559,25 @@ function fakeGitLab(options) {
 				} : {
 					path: action.file_path,
 					content: action.content ?? ""
-				}), body.commit_message),
+				}), body.commit_message, user.name ?? user.username, body.branch),
 				message: body.commit_message
 			}, 201);
 		}
+		if (rest === "/repository/commits" && request.method === "GET") {
+			const ref = url.searchParams.get("ref_name") ?? repo.defaultBranch;
+			const file = url.searchParams.get("path");
+			if (!repo.commitAt(repo.branches.get(ref) ?? ref)) return json({ message: "404 Reference Not Found" }, 404);
+			const perPage = Number(url.searchParams.get("per_page") ?? 20);
+			const page = Number(url.searchParams.get("page") ?? 1);
+			return json((file ? repo.history(file, ref) : []).slice((page - 1) * perPage, page * perPage).map((commit) => ({
+				id: commit.sha,
+				title: commit.message.split("\n")[0],
+				message: commit.message,
+				author_name: commit.author ?? "GitLab",
+				authored_date: commit.date,
+				committed_date: commit.date
+			})));
+		}
 		if (rest === "/repository/compare") return json({ diffs: repo.changedPaths(url.searchParams.get("from") ?? "", url.searchParams.get("to") ?? "").map((changedPath) => ({
 			old_path: changedPath,
 			new_path: changedPath
@@ -174,6 +586,15 @@ function fakeGitLab(options) {
 		if (statuses) {
 			const pipeline = pipelines.get(statuses[1] ?? "");
 			if (!pipeline) return json([]);
+			const failure = failures.get(statuses[1] ?? "");
+			if (failure) {
+				const id = pipelineId(statuses[1] ?? "");
+				return json([{
+					name: failure.job,
+					status: "failed",
+					target_url: `${webUrl}/${options.project}/-/jobs/${id}`
+				}]);
+			}
 			pipeline.checks += 1;
 			return json([{
 				name: "pages",
@@ -181,14 +602,111 @@ function fakeGitLab(options) {
 				target_url: `${webUrl}/${options.project}/-/jobs/1`
 			}]);
 		}
-		if (rest === "/pipelines") return json([...pipelines.keys()].map((sha, index) => ({
-			id: index + 1,
-			sha
+		if (rest === "/pipelines" && url.searchParams.has("ref")) return json([...updateRuns].reverse().map((run) => ({
+			id: run.id,
+			source: run.source,
+			status: run.status,
+			created_at: "2026-01-05T04:17:00Z",
+			web_url: `${webUrl}/${options.project}/-/pipelines/${run.id}`
 		})));
+		if (rest === "/pipeline" && request.method === "POST") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const run = addUpdateRun({
+				source: "api",
+				status: "created",
+				variables: (await request.json()).variables
+			});
+			return json({
+				id: run.id,
+				status: run.status
+			}, 201);
+		}
+		if (rest === "/pipeline_schedules") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			if (request.method === "POST") {
+				const body = await request.json();
+				const schedule = {
+					id: updateSettings.schedules.length + 1,
+					ref: body.ref,
+					cron: body.cron,
+					active: body.active ?? true
+				};
+				updateSettings.schedules.push(schedule);
+				return json(schedule, 201);
+			}
+			return json(updateSettings.schedules);
+		}
+		if (rest === "" && request.method === "PUT") {
+			if (accessLevel < 40) return json({ message: "403 Forbidden" }, 403);
+			const body = await request.json();
+			if (body.ci_push_repository_for_job_token_allowed !== void 0) updateSettings.jobTokenPush = body.ci_push_repository_for_job_token_allowed;
+			return json({ ci_push_repository_for_job_token_allowed: updateSettings.jobTokenPush });
+		}
+		const updateJobs = rest.match(/^\/pipelines\/(\d{4,})\/jobs$/);
+		if (updateJobs) {
+			const run = updateRuns.find((candidate) => candidate.id === Number(updateJobs[1]));
+			return run ? json([{
+				id: run.id,
+				name: "pages",
+				status: run.status
+			}]) : json({ message: "404 Not Found" }, 404);
+		}
+		const updateTrace = rest.match(/^\/jobs\/(\d{4,})\/trace$/);
+		if (updateTrace) {
+			const run = updateRuns.find((candidate) => candidate.id === Number(updateTrace[1]));
+			return run ? new Response(run.trace) : json({ message: "404 Not Found" }, 404);
+		}
+		if (rest === "/pipelines") {
+			const sha = url.searchParams.get("sha");
+			return json([...pipelines.keys()].map((pipelineSha, index) => ({
+				id: index + 1,
+				sha: pipelineSha
+			})).filter((pipeline) => !sha || pipeline.sha === sha));
+		}
+		const pipelineJobs = rest.match(/^\/pipelines\/(\d+)\/jobs$/);
+		if (pipelineJobs) {
+			const id = Number(pipelineJobs[1]);
+			const sha = [...pipelines.keys()][id - 1];
+			if (!sha) return json({ message: "404 Not Found" }, 404);
+			const failure = failures.get(sha);
+			return json([failure ? {
+				id,
+				name: failure.job,
+				status: "failed",
+				failure_reason: failure.failureReason
+			} : {
+				id,
+				name: "pages",
+				status: "success"
+			}]);
+		}
+		const trace = rest.match(/^\/jobs\/(\d+)\/trace$/);
+		if (trace) {
+			const sha = [...pipelines.keys()][Number(trace[1]) - 1];
+			const failure = sha ? failures.get(sha) : void 0;
+			return failure ? new Response(failure.trace) : json({ message: "404 Not Found" }, 404);
+		}
 		return json({ message: "404 Not Found" }, 404);
 	}
 	return {
+		/** How many GraphQL requests read files, as `readFiles()` makes. */
+		get graphqlReads() {
+			return graphqlReads;
+		},
+		/** The project's members by user id, invitations by email, and protected branches, which tests can change. */
+		members,
+		invitations,
+		protectedBranches,
+		failBuild,
+		/** The project's update settings, and the pipelines the update ran in, which tests add with `addUpdateRun()`. */
+		updateSettings,
+		updateRuns,
+		addUpdateRun,
 		repo,
+		/** Projects created through the API, by full path. */
+		created,
+		/** The site's GitLab Pages, if it has them, which tests can change. */
+		pages,
 		requests,
 		commit,
 		authorize,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/gitlab",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Edit a Goodfellow site stored on GitLab, straight from the browser.",
   "keywords": [
     "goodfellow",
@@ -10,12 +10,12 @@
     "gitlab",
     "git-based-cms"
   ],
-  "homepage": "https://chartung17.github.io/goodfellow-cms/docs/hosts",
-  "bugs": "https://github.com/chartung17/goodfellow-cms/issues",
+  "homepage": "https://goodfellow-cms.github.io/goodfellow-cms/docs/hosts",
+  "bugs": "https://github.com/goodfellow-cms/goodfellow-cms/issues",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/chartung17/goodfellow-cms.git",
+    "url": "git+https://github.com/goodfellow-cms/goodfellow-cms.git",
     "directory": "packages/gitlab"
   },
   "type": "module",
@@ -35,7 +35,7 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/core": "0.1.0"
+    "@goodfellow-cms/core": "0.3.0"
   },
   "devDependencies": {
     "@puckeditor/core": "0.23.0"