@goodfellow-cms/github 0.1.0 → 0.2.0

package/dist/testing.d.ts

@@ -6,6 +6,52 @@ export interface FakeGitHubUser {
   name?: string;
   /** Whether the user may publish. Defaults to true. */
   push?: boolean;
+  /** Whether the token may write `.github/workflows/`. Defaults to true. */
+  workflow?: boolean;
+  /** Whether the token may change GitHub Pages settings. Defaults to true. */
+  pages?: boolean;
+  /** Whether the user is an owner (admin) of the site's repository. Defaults to false. */
+  admin?: boolean;
+  /** Whether the token has GitHub's Administration permission, which changing collaborators needs. Defaults to false. */
+  administration?: boolean;
+  /** Whether the token may read GitHub Actions. Defaults to true. */
+  actions?: boolean;
+  /** Whether the token may run workflows, as owner tokens can. Defaults to the `administration` setting. */
+  actionsWrite?: boolean;
+}
+/** A GitHub Actions workflow run, with its jobs and their steps. */
+export interface FakeRun {
+  id: number;
+  sha: string;
+  /** What started it: `push` (the default), `schedule` or `workflow_dispatch`. */
+  event?: string;
+  /** For `workflow_dispatch`, the inputs it was given. */
+  inputs?: Record<string, string>;
+  createdAt?: string;
+  status: "queued" | "in_progress" | "completed";
+  conclusion: "success" | "failure" | "startup_failure" | "cancelled" | null;
+  jobs: Array<{
+    name: string;
+    conclusion: string | null;
+    steps: Array<{
+      name: string;
+      conclusion: string | null;
+    }>;
+  }>;
+}
+/** A repository invitation that hasn't been accepted yet. */
+export interface FakeInvitation {
+  id: number;
+  login: string;
+  permission: "admin" | "write";
+}
+/** The site's GitHub Pages settings, as `GET /repos/{repo}/pages` reports them. */
+export interface FakePages {
+  html_url: string;
+  cname: string | null;
+  https_enforced: boolean;
+  /** The certificate's state, such as `new` while it's being issued and `approved` once it's ready. */
+  certificate?: string;
 }
 export interface FakeDeploymentStatus {
   state: "queued" | "in_progress" | "success" | "failure" | "error" | "inactive";
@@ -22,6 +68,29 @@ export interface FakeGitHubOptions {
    * reports success after being checked this many times. Off by default.
    */
   deployAfterChecks?: number;
+  /** Organizations the users belong to, which new repositories can be created in. */
+  orgs?: string[];
+  /** The default branch of repositories created through the API, as an account's settings choose. Defaults to `main`. */
+  newRepoBranch?: string;
+  /** Whether private repositories can have GitHub Pages and rules, as on paid plans. Off by default, as on the free plan. */
+  paidPlan?: boolean;
+  /** Publishes the site with GitHub Pages, at `https://<owner>.github.io/<name>/`. Off by default. */
+  pages?: boolean;
+  /** Domains another GitHub Pages site already uses. */
+  takenDomains?: string[];
+  /** Other GitHub accounts that exist, which can be invited. Every token's user exists too. */
+  accounts?: string[];
+}
+/** A repository created through the fake's API, as the setup page creates them. */
+export interface FakeCreatedRepo {
+  fullName: string;
+  private: boolean;
+  description?: string;
+  repo: FakeRepo;
+  pages?: {
+    build_type: string;
+  };
+  rulesets: unknown[];
 }
 interface Deployment {
   id: number;
@@ -31,11 +100,24 @@ interface Deployment {
 }
 export declare function fakeGitHub(options: FakeGitHubOptions): {
   repo: FakeRepo;
+  /** Repositories created through the API, by `owner/name`. */
+  created: Map<string, FakeCreatedRepo>;
+  /** The site's GitHub Pages settings, which tests can change, such as to issue the certificate. */
+  pages: {
+    current?: FakePages;
+  };
+  /** The repository's collaborators, by login, and invitations waiting to be accepted. */
+  collaborators: Map<string, "admin" | "push" | "read">;
+  invitations: FakeInvitation[];
+  accept: (login: string) => void;
   deployments: Deployment[];
+  /** GitHub Actions workflow runs, which tests add with `failBuild()`. */
+  runs: FakeRun[];
+  failBuild: (sha: string, step?: string, job?: string) => FakeRun;
   /** Every request received, for checking what the backend sent. */
   requests: Request[];
   /** Simulates someone else publishing. */
-  commit: (changes: FileChange[], message: string, expectedHead?: string) => string;
+  commit: (changes: FileChange[], message: string, expectedHead?: string, author?: string) => string;
   handle: (request: Request) => Promise<Response>;
   /** A `fetch` that answers from the fake instead of the network. */
   fetch: typeof fetch;

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { decodeBase64, encodeBase64Bytes } from "@goodfellow-cms/core";
-import { FakeConflictError, FakeRepo, fakeFileBytes } from "@goodfellow-cms/core/testing";
+import { FakeConflictError, FakeRepo, fakeFileBytes, fakeFileFromBytes } from "@goodfellow-cms/core/testing";
 //#region src/testing.ts
 /**
 * A fake of the parts of GitHub's API that `@goodfellow-cms/github` uses, backed by
@@ -19,8 +19,246 @@ function fakeGitHub(options) {
 		name: "Test Editor"
 	} };
 	const deployments = [];
+	const runs = [];
 	const requests = [];
 	let nextDeployment = 1;
+	const created = /* @__PURE__ */ new Map();
+	const [owner = "", name = ""] = options.repo.split("/");
+	const pages = { current: options.pages ? {
+		html_url: `https://${owner.toLowerCase()}.github.io/${name}/`,
+		cname: null,
+		https_enforced: false
+	} : void 0 };
+	const trees = /* @__PURE__ */ new Map();
+	/** The repository's collaborators and their permission. Every token's user is one. */
+	const collaborators = new Map(Object.values(tokens).map((user) => [user.login, user.admin ? "admin" : user.push === false ? "read" : "push"]));
+	const invitations = [];
+	const accounts = /* @__PURE__ */ new Set([...Object.values(tokens).map((user) => user.login), ...options.accounts ?? []]);
+	let nextInvitation = 1;
+	/** Collaborators and invitations, which only owners' tokens with the Administration permission can change. */
+	async function handleCollaborators(request, rest, user) {
+		const forbidden = () => json({ message: "Resource not accessible by personal access token" }, 403);
+		const canManage = user.admin === true && user.administration === true;
+		if (rest === "/collaborators" && request.method === "GET") return json([...collaborators].map(([login, permission]) => ({
+			login,
+			avatar_url: `https://avatars.example/${login}`,
+			permissions: {
+				admin: permission === "admin",
+				maintain: false,
+				push: permission !== "read",
+				pull: true
+			}
+		})));
+		if (rest === "/invitations" && request.method === "GET") {
+			if (!canManage) return forbidden();
+			return json(invitations.map((invitation) => ({
+				id: invitation.id,
+				invitee: {
+					login: invitation.login,
+					avatar_url: `https://avatars.example/${invitation.login}`
+				},
+				permissions: invitation.permission
+			})));
+		}
+		const collaborator = rest.match(/^\/collaborators\/([^/]+)$/);
+		if (collaborator) {
+			if (!canManage) return forbidden();
+			const login = decodeURIComponent(collaborator[1] ?? "");
+			if (request.method === "DELETE") {
+				collaborators.delete(login);
+				return new Response(null, { status: 204 });
+			}
+			if (request.method === "PUT") {
+				if (!accounts.has(login)) return json({ message: "Not Found" }, 404);
+				const { permission = "push" } = await request.json();
+				if (collaborators.has(login)) {
+					collaborators.set(login, permission);
+					return new Response(null, { status: 204 });
+				}
+				const existing = invitations.find((invitation) => invitation.login === login);
+				const invitation = existing ?? {
+					id: nextInvitation++,
+					login,
+					permission: "write"
+				};
+				invitation.permission = permission === "admin" ? "admin" : "write";
+				if (!existing) invitations.push(invitation);
+				return json({
+					id: invitation.id,
+					invitee: { login },
+					permissions: invitation.permission
+				}, 201);
+			}
+		}
+		const invitation = rest.match(/^\/invitations\/(\d+)$/);
+		if (invitation) {
+			if (!canManage) return forbidden();
+			const index = invitations.findIndex((candidate) => candidate.id === Number(invitation[1]));
+			if (index === -1) return json({ message: "Not Found" }, 404);
+			if (request.method === "DELETE") {
+				invitations.splice(index, 1);
+				return new Response(null, { status: 204 });
+			}
+			if (request.method === "PATCH") {
+				const { permissions } = await request.json();
+				invitations[index].permission = permissions;
+				return json({
+					id: invitations[index]?.id,
+					permissions
+				});
+			}
+		}
+	}
+	/**
+	* Simulates the deploy workflow failing for a commit at a step, such as
+	* `"Run npm ci"`, in the `build` job or another, or before any step ran.
+	*/
+	function failBuild(sha, step, job = "build") {
+		const run = {
+			id: runs.length + 1,
+			sha,
+			status: "completed",
+			conclusion: "failure",
+			jobs: [{
+				name: job,
+				conclusion: "failure",
+				steps: step ? [{
+					name: "Set up job",
+					conclusion: "success"
+				}, {
+					name: step,
+					conclusion: "failure"
+				}] : []
+			}]
+		};
+		runs.push(run);
+		return run;
+	}
+	/** Simulates an invited person accepting the invitation. */
+	function accept(login) {
+		const index = invitations.findIndex((invitation) => invitation.login === login);
+		const [invitation] = index === -1 ? [] : invitations.splice(index, 1);
+		if (invitation) collaborators.set(login, invitation.permission === "admin" ? "admin" : "push");
+	}
+	/** Repository creation and the Git data API, for repositories created through the fake. */
+	async function handleCreated(request, path, login) {
+		if (path === "/user/orgs") return json((options.orgs ?? []).map((org) => ({ login: org })));
+		const create = path === "/user/repos" ? login : path.match(/^\/orgs\/([^/]+)\/repos$/)?.[1];
+		if (create !== void 0 && request.method === "POST") {
+			if (path !== "/user/repos" && !options.orgs?.includes(create)) return json({ message: "Not Found" }, 404);
+			const body = await request.json();
+			if (!/^[\w.-]+$/.test(body.name)) return json({ message: "Repository creation failed." }, 422);
+			const fullName = `${create}/${body.name}`;
+			if (created.has(fullName) || fullName === options.repo) return json({
+				message: "Repository creation failed.",
+				errors: [{ message: "name already exists on this account" }]
+			}, 422);
+			const repo = new FakeRepo({ "README.md": `# ${body.name}\n` }, options.newRepoBranch ?? "main");
+			created.set(fullName, {
+				fullName,
+				private: body.private === true,
+				description: body.description,
+				repo,
+				rulesets: []
+			});
+			return json({
+				full_name: fullName,
+				html_url: `https://github.com/${fullName}`,
+				default_branch: repo.defaultBranch
+			}, 201);
+		}
+		const match = path.match(/^\/repos\/([^/]+\/[^/]+)(\/.*)?$/);
+		const site = created.get(decodeURIComponent(match?.[1] ?? ""));
+		if (!match || !site) return void 0;
+		const { repo } = site;
+		const rest = match[2] ?? "";
+		const method = request.method;
+		if (rest === "" && method === "GET") return json({
+			full_name: site.fullName,
+			default_branch: repo.defaultBranch,
+			permissions: { push: true }
+		});
+		if (rest === "" && method === "PATCH") {
+			const body = await request.json();
+			if (body.default_branch) {
+				if (!repo.branches.has(body.default_branch)) return json({ message: "Not Found" }, 422);
+				repo.defaultBranch = body.default_branch;
+			}
+			return json({
+				full_name: site.fullName,
+				default_branch: repo.defaultBranch
+			});
+		}
+		const ref = rest.match(/^\/git\/refs?\/heads\/(.+)$/);
+		if (ref && method === "GET") {
+			const sha = repo.branches.get(decodeURIComponent(ref[1] ?? ""));
+			return sha ? json({ object: { sha } }) : json({ message: "Not Found" }, 404);
+		}
+		if (ref && method === "DELETE") {
+			repo.branches.delete(decodeURIComponent(ref[1] ?? ""));
+			return new Response(null, { status: 204 });
+		}
+		if (ref && method === "PATCH") {
+			const body = await request.json();
+			const branch = decodeURIComponent(ref[1] ?? "");
+			const commit = repo.commitAt(body.sha);
+			if (!commit || !repo.branches.has(branch)) return json({ message: "Reference does not exist" }, 422);
+			if (!body.force && commit.parent !== repo.branches.get(branch)) return json({ message: "Update is not a fast forward" }, 422);
+			if (site.rulesets.length > 0 && commit.parent !== repo.branches.get(branch)) return json({ message: "Cannot force-push to this branch" }, 422);
+			repo.branches.set(branch, body.sha);
+			deploy(body.sha);
+			return json({ object: { sha: body.sha } });
+		}
+		if (rest === "/git/refs" && method === "POST") {
+			const body = await request.json();
+			repo.branches.set(body.ref.replace(/^refs\/heads\//, ""), body.sha);
+			return json({
+				ref: body.ref,
+				object: { sha: body.sha }
+			}, 201);
+		}
+		if (rest === "/git/blobs" && method === "POST") {
+			const body = await request.json();
+			return json({ sha: repo.blobSha(body.encoding === "base64" ? fakeFileFromBytes(decodeBase64(body.content)) : body.content) }, 201);
+		}
+		if (rest === "/git/trees" && method === "POST") {
+			const body = await request.json();
+			const files = /* @__PURE__ */ new Map();
+			for (const entry of body.tree) {
+				if (entry.path.startsWith(".github/workflows/") && user(request)?.workflow === false) return json({ message: "Resource not accessible by personal access token" }, 404);
+				const content = entry.content ?? repo.blobs.get(entry.sha ?? "");
+				if (content === void 0) return json({ message: `No blob ${entry.sha}` }, 422);
+				files.set(entry.path, content);
+			}
+			const sha = repo.blobSha(`tree:${[...files.keys()].join(",")}:${trees.size}`);
+			trees.set(sha, files);
+			return json({ sha }, 201);
+		}
+		if (rest === "/git/commits" && method === "POST") {
+			const body = await request.json();
+			const files = trees.get(body.tree);
+			if (!files) return json({ message: "Tree not found" }, 422);
+			return json({ sha: repo.addCommit(body.parents[0], body.message, new Map(files)) }, 201);
+		}
+		if (rest === "/pages" && method === "POST") {
+			if (site.private && !options.paidPlan) return json({ message: "Your current plan does not support GitHub Pages for this repository." }, 422);
+			site.pages = await request.json();
+			const [owner, name] = site.fullName.split("/");
+			return json({
+				html_url: `https://${owner}.github.io/${name}/`,
+				build_type: site.pages.build_type
+			}, 201);
+		}
+		if (rest === "/rulesets" && method === "POST") {
+			if (site.private && !options.paidPlan) return json({ message: "Upgrade to GitHub Pro" }, 403);
+			site.rulesets.push(await request.json());
+			return json({ id: site.rulesets.length }, 201);
+		}
+		return json({ message: "Not Found" }, 404);
+	}
+	function user(request) {
+		return tokens[request.headers.get("authorization")?.replace(/^Bearer /, "") ?? ""];
+	}
 	function deploy(sha) {
 		if (options.deployAfterChecks === void 0) return;
 		deployments.unshift({
@@ -30,8 +268,11 @@ function fakeGitHub(options) {
 			checks: 0
 		});
 	}
-	function commit(changes, message, expectedHead) {
-		const sha = repo.commit(changes, message, { expectedHead });
+	function commit(changes, message, expectedHead, author) {
+		const sha = repo.commit(changes, message, {
+			expectedHead,
+			author
+		});
 		deploy(sha);
 		return sha;
 	}
@@ -46,6 +287,13 @@ function fakeGitHub(options) {
 			name: user.name ?? null,
 			avatar_url: `https://avatars.example/${user.login}`
 		});
+		const setup = await handleCreated(request, path, user.login);
+		if (setup) return setup;
+		const account = path.match(/^\/users\/([^/]+)$/);
+		if (account) {
+			const login = decodeURIComponent(account[1] ?? "");
+			return accounts.has(login) ? json({ login }) : json({ message: "Not Found" }, 404);
+		}
 		if (path === "/graphql" && request.method === "POST") {
 			const { variables } = await request.json();
 			const { input } = variables;
@@ -66,7 +314,7 @@ function fakeGitHub(options) {
 				})), ...(input.fileChanges.deletions ?? []).map((deletion) => ({
 					path: deletion.path,
 					delete: true
-				}))], input.message.headline, input.expectedHeadOid) } } } });
+				}))], input.message.headline, input.expectedHeadOid, user.name ?? user.login) } } } });
 			} catch (error) {
 				if (error instanceof FakeConflictError) return json({
 					data: { createCommitOnBranch: null },
@@ -81,11 +329,44 @@ function fakeGitHub(options) {
 		const match = path.match(/^\/repos\/([^/]+\/[^/]+)(\/.*)?$/);
 		if (!match || decodeURIComponent(match[1] ?? "") !== options.repo) return json({ message: "Not Found" }, 404);
 		const rest = match[2] ?? "";
+		if (rest === "/pages" && request.method === "GET") {
+			const site = pages.current;
+			if (!site) return json({ message: "Not Found" }, 404);
+			return json({
+				html_url: site.cname ? `https://${site.cname}/` : site.html_url,
+				cname: site.cname,
+				https_enforced: site.https_enforced,
+				https_certificate: site.cname ? {
+					state: site.certificate ?? "new",
+					domains: [site.cname]
+				} : null
+			});
+		}
+		if (rest === "/pages" && request.method === "PUT") {
+			const site = pages.current;
+			if (!site) return json({ message: "Not Found" }, 404);
+			if (user.pages === false) return json({ message: "Resource not accessible by personal access token" }, 403);
+			const body = await request.json();
+			if (body.cname && options.takenDomains?.includes(body.cname)) return json({ message: `The CNAME \`${body.cname}\` is already taken.` }, 422);
+			if (body.https_enforced && !["approved", "issued"].includes(site.certificate ?? "")) return json({ message: "The certificate does not exist yet" }, 422);
+			if (body.cname !== void 0) {
+				site.cname = body.cname;
+				site.certificate = body.cname ? "new" : void 0;
+				if (!body.cname) site.https_enforced = false;
+			}
+			if (body.https_enforced !== void 0) site.https_enforced = body.https_enforced;
+			return new Response(null, { status: 204 });
+		}
 		if (rest === "") return json({
 			full_name: options.repo,
 			default_branch: repo.defaultBranch,
-			permissions: { push: user.push !== false }
+			permissions: {
+				push: user.push !== false,
+				admin: user.admin === true
+			}
 		});
+		const people = await handleCollaborators(request, rest, user);
+		if (people) return people;
 		const ref = rest.match(/^\/git\/ref\/heads\/(.+)$/);
 		if (ref) {
 			const sha = repo.branches.get(decodeURIComponent(ref[1] ?? ""));
@@ -117,6 +398,79 @@ function fakeGitHub(options) {
 				encoding: "base64"
 			});
 		}
+		if (rest === "/commits") {
+			const ref = url.searchParams.get("sha") ?? repo.defaultBranch;
+			const file = url.searchParams.get("path");
+			if (!repo.commitAt(repo.branches.get(ref) ?? ref)) return json({ message: "No commit found for SHA" }, 422);
+			const perPage = Number(url.searchParams.get("per_page") ?? 30);
+			const page = Number(url.searchParams.get("page") ?? 1);
+			return json((file ? repo.history(file, ref) : []).slice((page - 1) * perPage, page * perPage).map((commit) => ({
+				sha: commit.sha,
+				commit: {
+					message: commit.message,
+					author: {
+						name: commit.author ?? "GitHub",
+						date: commit.date
+					}
+				},
+				author: null
+			})));
+		}
+		if (rest === "/actions/workflows/deploy.yml/dispatches" && request.method === "POST") {
+			if (!(user.actionsWrite ?? user.administration)) return json({ message: "Resource not accessible by personal access token" }, 403);
+			const body = await request.json();
+			runs.push({
+				id: runs.length + 1,
+				sha: repo.head(body.ref),
+				event: "workflow_dispatch",
+				inputs: body.inputs,
+				status: "queued",
+				conclusion: null,
+				jobs: []
+			});
+			return new Response(null, { status: 204 });
+		}
+		if (rest === "/actions/workflows/deploy.yml/runs") {
+			if (user.actions === false) return json({ message: "Resource not accessible by personal access token" }, 403);
+			return json({
+				total_count: runs.length,
+				workflow_runs: [...runs].reverse().map((run) => ({
+					id: run.id,
+					event: run.event ?? "push",
+					head_sha: run.sha,
+					status: run.status,
+					conclusion: run.conclusion,
+					created_at: run.createdAt ?? "2026-01-05T04:17:00Z",
+					html_url: `https://github.com/${options.repo}/actions/runs/${run.id}`
+				}))
+			});
+		}
+		if (rest === "/actions/runs" || rest.startsWith("/actions/runs/")) {
+			if (user.actions === false) return json({ message: "Resource not accessible by personal access token" }, 403);
+			const htmlUrl = (run) => `https://github.com/${options.repo}/actions/runs/${run.id}`;
+			if (rest === "/actions/runs") {
+				const sha = url.searchParams.get("head_sha");
+				const found = runs.filter((run) => !sha || run.sha === sha);
+				return json({
+					total_count: found.length,
+					workflow_runs: found.map((run) => ({
+						id: run.id,
+						head_sha: run.sha,
+						status: run.status,
+						conclusion: run.conclusion,
+						name: "Deploy to GitHub Pages",
+						path: ".github/workflows/deploy.yml",
+						html_url: htmlUrl(run)
+					}))
+				});
+			}
+			const jobs = rest.match(/^\/actions\/runs\/(\d+)\/jobs$/);
+			const run = runs.find((candidate) => candidate.id === Number(jobs?.[1]));
+			return run ? json({
+				total_count: run.jobs.length,
+				jobs: run.jobs
+			}) : json({ message: "Not Found" }, 404);
+		}
 		const compare = rest.match(/^\/compare\/([0-9a-f]{40})\.\.\.([0-9a-f]{40})$/);
 		if (compare) return json({ files: repo.changedPaths(compare[1] ?? "", compare[2] ?? "").map((filename) => ({ filename })) });
 		if (rest === "/deployments") {
@@ -141,7 +495,18 @@ function fakeGitHub(options) {
 	}
 	return {
 		repo,
+		/** Repositories created through the API, by `owner/name`. */
+		created,
+		/** The site's GitHub Pages settings, which tests can change, such as to issue the certificate. */
+		pages,
+		/** The repository's collaborators, by login, and invitations waiting to be accepted. */
+		collaborators,
+		invitations,
+		accept,
 		deployments,
+		/** GitHub Actions workflow runs, which tests add with `failBuild()`. */
+		runs,
+		failBuild,
 		/** Every request received, for checking what the backend sent. */
 		requests,
 		/** Simulates someone else publishing. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/github",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Edit a Goodfellow site stored on GitHub, straight from the browser.",
   "keywords": [
     "goodfellow",
@@ -10,12 +10,12 @@
     "github",
     "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/github"
   },
   "type": "module",
@@ -35,7 +35,7 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/core": "0.1.0"
+    "@goodfellow-cms/core": "0.2.0"
   },
   "devDependencies": {
     "@puckeditor/core": "0.23.0"