Refactored the backend. It's written in typescript now.

1 files changed, 395 insertions, 0 deletions

diff --git a/packages/server/src/api/git.ts b/packages/server/src/api/git.ts
new file mode 100644
index 0000000..1f39692
--- /dev/null
+++ b/packages/server/src/api/git.ts
@@ -0,0 +1,395 @@
+import { ConvenientHunk, Repository, Revwalk, TreeEntry } from "nodegit";
+import { join, parse } from "path";
+import { readFile, readdir } from "fs";
+import { FastifyRequest } from "fastify";
+import { IncomingMessage } from "http";
+import { URL } from "whatwg-url";
+import { formatDistance } from "date-fns";
+import { spawn } from "child_process";
+import { verifyGitRequest } from "./util";
+
+function addRepoDirSuffix(repo_name: string) {
+	return repo_name.endsWith(".git") ? repo_name : `${repo_name}.git`;
+}
+
+function parseHunkAddDel(hunk: string[]) {
+	interface Lines {
+		new_lines: number[],
+		deleted_lines: number[]
+	}
+
+	const lines = hunk.reduce((lines_obj: Lines, line, index) => {
+		if(line.charAt(0) === "+") {
+			hunk[index] = line.slice(1);
+			lines_obj.new_lines.push(index);
+		}
+		else if(line.charAt(0) === "-") {
+			hunk[index] = line.slice(1);
+			lines_obj.deleted_lines.push(index);
+		}
+		return lines_obj;
+	}, { new_lines: [], deleted_lines: [] });
+
+	return Object.assign(lines, { hunk: hunk.join("\n") });
+}
+
+function getPatchHeaderData(patch_headers: string[], all_patches: string[]) {
+	interface PatchHeaderData {
+		indexes: number[],
+		lengths: number[],
+		last: number | null
+	};
+
+	return patch_headers.reduce((patch_header_data, line, index) => {
+		// The start of a patch header
+		if((/^diff --git/u).test(line)) {
+			patch_header_data.indexes.push(all_patches.indexOf(line));
+
+			if(patch_header_data.last !== null) {
+				patch_header_data.lengths.push(patch_headers.slice(patch_header_data.last, index).length);
+			}
+			patch_header_data.last = index;
+		}
+
+		// Include the last patch header when the end is reached
+		if(index === patch_headers.length - 1 && patch_header_data.last !== null) {
+			patch_header_data.lengths.push(patch_headers.slice(patch_header_data.last, index).length);
+		}
+
+		return patch_header_data;
+	}, <PatchHeaderData>{ indexes: [], lengths: [], last: null });
+}
+
+function getHunksData(hunks: ConvenientHunk[], patch_content: string[]) {
+	return hunks.reduce((hunks_data, hunk, hunk_index) => {
+		const hunk_header = hunk.header();
+		const hunk_header_index = patch_content.indexOf(hunk_header.replace(/\n/gu, ""));
+
+		if(hunks_data.prev !== null) {
+			const prev_hunk = hunks[hunk_index - 1];
+			hunks_data.hunks.push({
+				new_start: prev_hunk.newStart(),
+				new_lines: prev_hunk.newLines(),
+				old_start: prev_hunk.oldStart(),
+				old_lines: prev_hunk.oldLines(),
+				...parseHunkAddDel(patch_content.slice(hunks_data.prev, hunk_header_index))
+			});
+		}
+
+		hunks_data.prev = hunk_header_index;
+		return hunks_data;
+	}, { prev: null, hunks: [] });
+}
+
+function Patch(patch, too_large, hunks) {
+	this.from = patch.oldFile().path();
+	this.to = patch.newFile().path();
+	this.additions = patch.lineStats()["total_additions"];
+	this.deletions = patch.lineStats()["total_deletions"];
+	this.too_large = too_large;
+	this.hunks = hunks;
+}
+
+export type GitRequestInfo = {
+	repo: string,
+	url_path: string,
+	parsed_url: URL,
+	url_path_parts: string[],
+	is_discovery: boolean,
+	service: string | null,
+	content_type: string
+};
+
+function extractRequestInfo(req: FastifyRequest): GitRequestInfo {
+	const params: any = req.params;
+
+	const repo = params.repo + ".git";
+	const url_path = req.url.replace(params.repo, repo);
+
+	const parsed_url = new URL(`${req.protocol}://${req.hostname}${url_path}`);
+	const url_path_parts = parsed_url.pathname.split("/");
+
+	const is_discovery = (/\/info\/refs$/u).test(parsed_url.pathname);
+
+	const service = is_discovery ? parsed_url.searchParams.get("service") : url_path_parts[url_path_parts.length - 1];
+
+	const content_type = `application/x-${service}-${is_discovery ? "advertisement" : "result"}`;
+
+	return {
+		repo,
+		url_path,
+		parsed_url,
+		is_discovery,
+		url_path_parts,
+		service,
+		content_type
+	};
+}
+
+async function getTreeEntryLastCommit(repo: Repository, tree_entry: TreeEntry) {
+	const walker = Revwalk.create(repo);
+	walker.pushHead();
+
+	interface LastTreeEntryCommit {
+		id: string | null,
+		message: string | null,
+		date: Date | null
+	};
+
+	const raw_commits = await walker.getCommitsUntil(() => true);
+
+	return raw_commits.reduce((acc, commit) => acc.then(obj => {
+		if(obj.id === null) {
+			return commit.getDiff().then(diffs => diffs[0].patches().then(patches => {
+				let matching_path_patch = null;
+				if(tree_entry.isBlob()) {
+					matching_path_patch = patches.find(patch => patch.newFile().path() === tree_entry.path());
+				}
+				else {
+					matching_path_patch = patches.find(patch => parse(patch.newFile().path()).dir.startsWith(tree_entry.path()));
+				}
+
+				if(matching_path_patch) {
+					obj.id = commit.sha();
+					obj.message = commit.message().replace(/\n/gu, "");
+					obj.date = commit.date();
+				}
+				return obj;
+			}));
+		}
+
+		return obj;
+	}), Promise.resolve(<LastTreeEntryCommit>{ id: null, message: null, date: null }));
+}
+
+export class Git {
+	base_dir: string;
+
+	constructor(base_dir: string) {
+		this.base_dir = base_dir;
+	}
+
+	async getLog(repo_name: string) {
+		const full_repo_name = addRepoDirSuffix(repo_name);
+		const repo = await Repository.openBare(`${this.base_dir}/${full_repo_name}`);
+
+		const walker: Revwalk = Revwalk.create(repo);
+		walker.pushHead();
+
+		const raw_commits = await walker.getCommitsUntil(() => true);
+
+		const commits = await Promise.all(raw_commits.map(async commit => ({
+			commit: commit.sha(),
+			author_full: commit.author().toString(),
+			author_name: commit.author().name(),
+			author_email: commit.author().email(),
+			date: commit.date(),
+			message: commit.message().replace(/\n/gu, ""),
+			insertions: (await (await commit.getDiff())[0].getStats()).insertions(),
+			deletions: (await (await commit.getDiff())[0].getStats()).deletions(),
+			files_changed: (await (await commit.getDiff())[0].getStats()).filesChanged()
+		})));
+
+		return commits;
+	}
+
+	async getTimeSinceLatestCommit(repo_name: string) {
+		const full_repo_name = addRepoDirSuffix(repo_name);
+		const repo = await Repository.openBare(`${this.base_dir}/${full_repo_name}`);
+
+		const master_commit = await repo.getMasterCommit();
+
+		return formatDistance(new Date(), master_commit.date());
+	}
+
+	getRepoFile(repo_name: string, file: string) {
+		return new Promise(resolve => {
+			const full_repo_name = addRepoDirSuffix(repo_name);
+			readFile(`${this.base_dir}/${full_repo_name}/${file}`, (err, content) => {
+				if(!err) {
+					resolve(content.toString().replace(/\n/gu, ""));
+					return;
+				}
+				resolve("");
+			});
+		});
+	}
+
+	getRepos() {
+		return new Promise(resolve => {
+			readdir(this.base_dir, (err: Error, dir_content: string[]) => {
+				if(err) {
+					resolve({ "error": err });
+					return;
+				}
+
+				dir_content.filter(repo => repo.endsWith(".git")).reduce((acc, repo) => {
+					return acc.then((repos: any) => {
+						return this.getRepoFile(repo, "description").then(description => {
+							return this.getRepoFile(repo, "owner").then(owner => {
+								return this.getTimeSinceLatestCommit(repo).then(last_commit_date => {
+									repos[repo.slice(0, -4)] = { "description": description, "owner": owner, "last_updated": last_commit_date };
+									return repos;
+								});
+							});
+						});
+					});
+				}, Promise.resolve({}))
+					.then(repos => {
+						resolve(repos);
+					});
+			});
+		});
+	}
+
+	async getCommit(repo_name: string, commit_oid: string) {
+		const full_repo_name = addRepoDirSuffix(repo_name);
+		const repo = await Repository.openBare(`${this.base_dir}/${full_repo_name}`);
+		const commit = await repo.getCommit(commit_oid);
+		const diff = (await commit.getDiff())[0];
+		const all_patches = (await diff.toBuf(1)).toString().split("\n");
+		const patch_header_data = getPatchHeaderData((await diff.toBuf(2)).toString().split("\n"), all_patches);
+
+		const parsed_patches = (await diff.patches()).reduce((acc, patch, patch_index) => {
+			return acc.then(arr => patch.hunks().then(hunks => {
+				const patch_start = patch_header_data.indexes[patch_index] + patch_header_data.lengths[patch_index];
+				const patch_end = (typeof patch_header_data.indexes[patch_index + 1] === "undefined") ? all_patches.length - 1 : patch_header_data.indexes[patch_index + 1];
+				const patch_content = all_patches.slice(patch_start, patch_end);
+
+				const line_lengths = patch_content.map(line => line.length).reduce((result, length) => result + length);
+
+				if(patch_content.length > 5000 || line_lengths > 5000) {
+					console.log("Too large!");
+
+					arr.push(new Patch(patch, true, null));
+					return arr;
+				}
+
+				const hunks_data = getHunksData(hunks, patch_content);
+
+				const prev_hunk = hunks[hunks.length - 1];
+				hunks_data.hunks.push({
+					new_start: prev_hunk.newStart(),
+					new_lines: prev_hunk.newLines(),
+					old_start: prev_hunk.oldStart(),
+					old_lines: prev_hunk.oldLines(),
+					...parseHunkAddDel(patch_content.slice(hunks_data.prev, patch_end))
+				});
+
+				arr.push(new Patch(patch, false, hunks_data.hunks));
+
+				return arr;
+			}));
+		}, Promise.resolve([]));
+
+		return {
+			hash: commit.sha(),
+			author: commit.author().toString(),
+			message: commit.message(),
+			date: commit.date(),
+			patches: await parsed_patches
+		};
+	}
+
+	connectToGitHTTPBackend(req, reply) {
+		const request_info = extractRequestInfo(req);
+
+		const valid_request = verifyGitRequest(request_info);
+		if(valid_request.success === false) {
+			reply.header("Content-Type", request_info.content_type);
+			reply.code(valid_request.code).send(valid_request.message);
+			return;
+		}
+
+		reply.raw.writeHead(200, { "Content-Type": request_info.content_type });
+
+		const spawn_args = [ "--stateless-rpc", join(this.base_dir, request_info.repo) ];
+		if(request_info.is_discovery) {
+			spawn_args.push("--advertise-refs");
+		}
+
+		const git_pack = spawn(request_info.service, spawn_args);
+
+		if(request_info.is_discovery) {
+			const s = "# service=" + request_info.service + "\n";
+			const n = (4 + s.length).toString(16);
+			reply.raw.write(Buffer.from((Array(4 - n.length + 1).join("0") + n + s) + "0000"));
+		}
+		else {
+			const request_body: IncomingMessage = req.raw;
+
+			request_body.on("data", data => git_pack.stdin.write(data));
+			request_body.on("close", () => git_pack.stdin.end());
+		}
+
+		git_pack.on("error", err => console.log(err));
+
+		git_pack.stderr.on("data", (stderr: Buffer) => console.log(stderr.toString()));
+		git_pack.stdout.on("data", data => reply.raw.write(data));
+
+		git_pack.on("close", () => reply.raw.end());
+	}
+
+	async getTree(repo_name, tree_path) {
+		const full_repo_name = addRepoDirSuffix(repo_name);
+		const repo = await Repository.openBare(`${this.base_dir}/${full_repo_name}`);
+		const master_commit = await repo.getMasterCommit();
+
+		const tree = await master_commit.getTree();
+
+		let entries = [];
+		if(tree_path) {
+			try {
+				const path_entry = await tree.getEntry(tree_path);
+
+				if(path_entry.isBlob()) {
+					return { type: "blob", content: (await path_entry.getBlob()).content().toString() };
+				}
+
+				entries = await (await path_entry.getTree()).entries();
+			}
+			catch(err) {
+				if(err.errno === -3) {
+					return { error: 404 };
+				}
+				return { error: 500 };
+			}
+		}
+		else {
+			entries = tree.entries();
+		}
+
+		return {
+			type: "tree",
+			tree: await entries.reduce((acc, entry) => {
+				return acc.then(obj => {
+					return getTreeEntryLastCommit(repo, entry).then(last_commit => {
+						obj[parse(entry.path()).base] = {
+							oid: entry.oid(),
+							type: entry.isBlob() ? "blob" : "tree",
+							last_commit: {
+								id: last_commit.id,
+								message: last_commit.message,
+								date: last_commit.date
+							}
+						};
+						return obj;
+					});
+				});
+			}, Promise.resolve({}))
+		};
+	}
+
+	async doesCommitExist(repo_name, commit_oid) {
+		const full_repo_name = addRepoDirSuffix(repo_name);
+		const repo = await Repository.openBare(`${this.base_dir}/${full_repo_name}`);
+
+		try {
+			await repo.getCommit(commit_oid);
+			return true;
+		}
+		catch {
+			return false;
+		}
+	}
+};
\ No newline at end of file