From c63e558f402cfad914031a58fdcf3d8e0f3d125d Mon Sep 17 00:00:00 2001 From: HampusM Date: Sun, 25 Jul 2021 12:32:59 +0200 Subject: Moved backend routes to a dedicated directory --- packages/server/src/routes/api/v1/repo/branches.ts | 48 +++++++++ packages/server/src/routes/api/v1/repo/index.ts | 114 +++++++++++++++++++++ packages/server/src/routes/api/v1/repo/log.ts | 81 +++++++++++++++ 3 files changed, 243 insertions(+) create mode 100644 packages/server/src/routes/api/v1/repo/branches.ts create mode 100644 packages/server/src/routes/api/v1/repo/index.ts create mode 100644 packages/server/src/routes/api/v1/repo/log.ts (limited to 'packages/server/src/routes/api/v1/repo') diff --git a/packages/server/src/routes/api/v1/repo/branches.ts b/packages/server/src/routes/api/v1/repo/branches.ts new file mode 100644 index 0000000..10ac736 --- /dev/null +++ b/packages/server/src/routes/api/v1/repo/branches.ts @@ -0,0 +1,48 @@ +import { FastifyInstance, FastifyPluginOptions } from "fastify"; +import { Branch } from "../../../../git/branch"; +import { Route } from "../../../../types/fastify"; +import { BranchSummary as APIBranchSummary, Branch as APIBranch } from "shared_types"; + +export default function(fastify: FastifyInstance, opts: FastifyPluginOptions, done: (err?: Error) => void): void { + fastify.route({ + method: "GET", + url: "/branches", + handler: async(req, reply) => { + const branches = await req.repository.branches(); + + reply.send({ + data: branches.map(branch => { + return { + id: branch.id, + name: branch.name + }; + }) + }); + } + }); + + fastify.route({ + method: "GET", + url: "/branches/:branch", + handler: async(req, reply) => { + const branch = await Branch.lookup(req.repository, req.params.branch); + + if(!branch) { + reply.code(404).send({ error: "Branch not found!" }); + return; + } + + const data: APIBranch = { + id: branch.id, + name: branch.name, + latest_commit: await branch.latestCommit() + }; + + reply.send({ + data: data + }); + } + }); + + done(); +} \ No newline at end of file diff --git a/packages/server/src/routes/api/v1/repo/index.ts b/packages/server/src/routes/api/v1/repo/index.ts new file mode 100644 index 0000000..0042b60 --- /dev/null +++ b/packages/server/src/routes/api/v1/repo/index.ts @@ -0,0 +1,114 @@ +import { CoolFastifyRequest, Route } from "../../../../types/fastify"; +import { FastifyInstance, FastifyPluginOptions } from "fastify"; +import { Blob } from "../../../../git/blob"; +import { Repository } from "../../../../git/repository"; +import { Tag } from "../../../../git/tag"; +import { TreeEntry } from "../../../../git/tree_entry"; +import { basename } from "path"; +import branches from "./branches"; +import log from "./log"; +import { verifyRepoName } from "../../util"; +import { Tree as APITree, Tag as APITag, TreeEntry as APITreeEntry } from "shared_types"; +import { BaseError } from "../../../../git/error"; +import { Tree } from "../../../../git/tree"; + +declare module "fastify" { + interface FastifyRequest { + repository: Repository, + } +} + +function addHooks(fastify: FastifyInstance, opts: FastifyPluginOptions): void { + fastify.addHook("preHandler", async(req: CoolFastifyRequest, reply) => { + const repository = await Repository.open(opts.config.settings.base_dir, req.params.repo, req.query.branch).catch((err: BaseError) => err); + + if(repository instanceof BaseError) { + reply.code(repository.code).send({ error: repository.message }); + return; + } + + req.repository = repository; + }); + + fastify.addHook("onRequest", async(req: CoolFastifyRequest, reply) => { + if(!verifyRepoName(req.params.repo)) { + reply.code(400).send({ error: "Bad request" }); + } + }); +} +async function treeEntryMap(entry: TreeEntry) { + const latest_commit = await entry.latestCommit(); + return { + name: basename(entry.path), + type: entry.type, + latest_commit: { + id: latest_commit.id, + message: latest_commit.message, + date: latest_commit.date + } + }; +} + +async function tagMap(tag: Tag) { + const author = await tag.author(); + return { + name: tag.name, + author: { name: author.name, email: author.email }, + date: await tag.date() + }; +} + +export default function(fastify: FastifyInstance, opts: FastifyPluginOptions, done: (err?: Error) => void): void { + addHooks(fastify, opts); + + fastify.register(log); + fastify.register(branches); + + fastify.route({ + method: "GET", + url: "/tree", + handler: async(req, reply) => { + const tree: Tree | BaseError = await req.repository.tree().catch(err => err); + + if(tree instanceof BaseError) { + reply.code(tree.code).send({ error: tree.message }); + return; + } + + const tree_path = (Object.keys(req.query).length !== 0 && req.query.path) ? req.query.path : null; + + let data: APITree; + + if(tree_path) { + const tree_path_entry: Tree | Blob | BaseError = await tree.find(tree_path).catch(err => err); + + if(tree_path_entry instanceof BaseError) { + reply.code(tree_path_entry.code).send({ error: tree_path_entry.message }); + return; + } + + data = tree_path_entry instanceof Blob + ? { type: "blob", content: await tree_path_entry.content() } + : { type: "tree", content: await Promise.all(tree_path_entry.entries().map(treeEntryMap)) }; + } + else { + data = { type: "tree", content: await Promise.all(tree.entries().map(treeEntryMap)) }; + } + + reply.send({ data: data }); + } + }); + + fastify.route({ + method: "GET", + url: "/tags", + handler: async(req, reply) => { + const tags = await req.repository.tags(); + reply.send({ + data: await Promise.all(tags.map(tagMap)) + }); + } + }); + + done(); +} \ No newline at end of file diff --git a/packages/server/src/routes/api/v1/repo/log.ts b/packages/server/src/routes/api/v1/repo/log.ts new file mode 100644 index 0000000..5ba4044 --- /dev/null +++ b/packages/server/src/routes/api/v1/repo/log.ts @@ -0,0 +1,81 @@ +import { FastifyInstance, FastifyPluginOptions } from "fastify"; +import { Commit } from "../../../../git/commit"; +import { Patch } from "../../../../git/patch"; +import { Route } from "../../../../types/fastify"; +import { verifySHA } from "../../util"; +import { LogCommit as APILogCommit, Patch as APIPatch, Commit as APICommit } from "shared_types"; + +async function commitMap(commit: Commit) { + const stats = await commit.stats(); + return { + id: commit.id, + author: { + name: commit.author.name, + email: commit.author.email + }, + message: commit.message, + date: commit.date, + insertions: stats.insertions, + deletions: stats.deletions, + files_changed: stats.files_changed + }; +} + +async function patchMap(patch: Patch, index: number) { + return { + additions: patch.additions, + deletions: patch.deletions, + from: patch.from, + to: patch.to, + too_large: await patch.isTooLarge(index), + hunks: await patch.getHunks(index) + }; +} + +export default function(fastify: FastifyInstance, opts: FastifyPluginOptions, done: (err?: Error) => void): void { + fastify.route({ + method: "GET", + url: "/log", + handler: async(req, reply) => { + const commits = await req.repository.commits(); + + reply.send({ + data: await Promise.all(commits.map(commitMap)) + }); + } + }); + + fastify.route({ + method: "GET", + url: "/log/:commit", + handler: async(req, reply) => { + const commit_verification = await verifySHA(req.repository, req.params.commit); + if(commit_verification.success === false && commit_verification.code) { + reply.code(commit_verification.code).send({ error: commit_verification.message }); + } + + const commit = await Commit.lookup(req.repository, req.params.commit); + + const stats = await commit.stats(); + + const data: APICommit = { + message: commit.message, + author: { + name: commit.author.name, + email: commit.author.email + }, + date: commit.date, + insertions: stats.insertions, + deletions: stats.deletions, + files_changed: stats.files_changed, + diff: await Promise.all((await (await commit.diff()).patches()).map(patchMap)) + }; + + reply.send({ + data: data + }); + } + }); + + done(); +} \ No newline at end of file -- cgit v1.2.3-18-g5258