@tequila99/githuman 0.2.3 → 0.4.0

package/dist/server/routes/comments.js

@@ -1,6 +1,7 @@
+import { NotFoundError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
 import { getReview } from "../services/review.service.js";
-import { createComment, getComments, editComment, removeComment, resolveComment, unresolveComment, ValidationError } from "../services/comment.service.js";
+import { createComment, getComments, editComment, removeComment, resolveComment, unresolveComment } from "../services/comment.service.js";
 // Null goes first in each union: Fastify's Ajv coerces types, and with
 // Integer (or String) first it turns a JSON null into 0 (or "") before the
 // Null branch is ever tried — a file-level comment would be stored as line 0.
@@ -27,87 +28,36 @@ export async function commentRoutes(app, opts) {
     const typedApp = app.withTypeProvider();
     typedApp.post('/api/reviews/:id/comments', { schema: { params: ReviewIdParams, body: CreateCommentBody } }, async (request, reply) => {
         if (!getReview(db, request.params.id)) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
-        }
-        try {
-            const comment = createComment(db, request.params.id, request.body, eventBus);
-            reply.code(201);
-            return comment;
-        }
-        catch (error) {
-            if (error instanceof ValidationError) {
-                reply.code(400);
-                return {
-                    error: 'Bad Request',
-                    message: error.message,
-                    statusCode: 400
-                };
-            }
-            throw error;
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
+        const comment = createComment(db, request.params.id, request.body, eventBus);
+        reply.code(201);
+        return comment;
     });
-    typedApp.get('/api/reviews/:id/comments', { schema: { params: ReviewIdParams } }, async (request, reply) => {
+    typedApp.get('/api/reviews/:id/comments', { schema: { params: ReviewIdParams } }, async (request) => {
         if (!getReview(db, request.params.id)) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         return getComments(db, request.params.id);
     });
-    typedApp.patch('/api/comments/:id', { schema: { params: CommentIdParams, body: UpdateCommentBody } }, async (request, reply) => {
-        try {
-            const updated = editComment(db, request.params.id, request.body.content, eventBus);
-            if (!updated) {
-                reply.code(404);
-                return {
-                    error: 'Not Found',
-                    message: `Comment ${request.params.id} not found`,
-                    statusCode: 404
-                };
-            }
-            return updated;
-        }
-        catch (error) {
-            if (error instanceof ValidationError) {
-                reply.code(400);
-                return {
-                    error: 'Bad Request',
-                    message: error.message,
-                    statusCode: 400
-                };
-            }
-            throw error;
+    typedApp.patch('/api/comments/:id', { schema: { params: CommentIdParams, body: UpdateCommentBody } }, async (request) => {
+        const updated = editComment(db, request.params.id, request.body.content, eventBus);
+        if (!updated) {
+            throw new NotFoundError(`Comment ${request.params.id} not found`);
         }
+        return updated;
     });
-    typedApp.patch('/api/comments/:id/resolve', { schema: { params: CommentIdParams } }, async (request, reply) => {
+    typedApp.patch('/api/comments/:id/resolve', { schema: { params: CommentIdParams } }, async (request) => {
         const updated = resolveComment(db, request.params.id, eventBus);
         if (!updated) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Comment ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Comment ${request.params.id} not found`);
         }
         return updated;
     });
-    typedApp.patch('/api/comments/:id/unresolve', { schema: { params: CommentIdParams } }, async (request, reply) => {
+    typedApp.patch('/api/comments/:id/unresolve', { schema: { params: CommentIdParams } }, async (request) => {
         const updated = unresolveComment(db, request.params.id, eventBus);
         if (!updated) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Comment ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Comment ${request.params.id} not found`);
         }
         return updated;
     });

package/dist/server/routes/diff.js

@@ -1,5 +1,8 @@
+import { BadRequestError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
-import { getStagedDiff, getUnstagedDiff, getBranchDiff, getCommitsDiff } from "../services/diff.service.js";
+import { getStagedDiff, getUnstagedDiff, getBranchDiff, getCommitsDiff, getDiffSummaries, getFileDiff } from "../services/diff.service.js";
+import { resolveWithinRepo } from "../services/git.service.js";
+import { errorMessage } from "../../shared/utils/error-message.js";
 const BranchQuery = Type.Object({
     base: Type.String({ minLength: 1 })
 });
@@ -7,6 +10,19 @@ const CommitsQuery = Type.Object({
     from: Type.String({ minLength: 1 }),
     to: Type.String({ minLength: 1 })
 });
+const SourceParams = Type.Object({
+    source: Type.Union([Type.Literal('staged'), Type.Literal('unstaged')])
+});
+const FileQuery = Type.Object({
+    path: Type.String({ minLength: 1 }),
+    oldPath: Type.Optional(Type.String({ minLength: 1 })),
+    status: Type.Union([
+        Type.Literal('added'),
+        Type.Literal('modified'),
+        Type.Literal('deleted'),
+        Type.Literal('renamed')
+    ])
+});
 export async function diffRoutes(app, opts) {
     const { repositoryPath } = opts;
     const typedApp = app.withTypeProvider();
@@ -16,24 +32,41 @@ export async function diffRoutes(app, opts) {
     typedApp.get('/api/diff/unstaged', async () => {
         return getUnstagedDiff(repositoryPath);
     });
-    typedApp.get('/api/diff/branch', { schema: { querystring: BranchQuery } }, async (request, reply) => {
+    // Files without hunks, then one file with hunks: the list stays small (ADR 0033).
+    typedApp.get('/api/diff/:source/files', { schema: { params: SourceParams } }, async (request) => getDiffSummaries(repositoryPath, request.params.source));
+    typedApp.get('/api/diff/:source/file', { schema: { params: SourceParams, querystring: FileQuery } }, async (request) => {
+        const { path, oldPath, status } = request.query;
+        // Only a path outside the repository is a bad request. Other errors stay server errors.
+        try {
+            resolveWithinRepo(repositoryPath, path);
+            if (oldPath !== undefined)
+                resolveWithinRepo(repositoryPath, oldPath);
+        }
+        catch (err) {
+            throw new BadRequestError(errorMessage(err), { cause: err });
+        }
+        return getFileDiff(repositoryPath, request.params.source, {
+            oldPath: oldPath ?? path,
+            newPath: path,
+            status
+        });
+    });
+    typedApp.get('/api/diff/branch', { schema: { querystring: BranchQuery } }, async (request) => {
         try {
             return await getBranchDiff(repositoryPath, request.query.base);
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Bad ref';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.get('/api/diff/commits', { schema: { querystring: CommitsQuery } }, async (request, reply) => {
+    typedApp.get('/api/diff/commits', { schema: { querystring: CommitsQuery } }, async (request) => {
         try {
             return await getCommitsDiff(repositoryPath, request.query.from, request.query.to);
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Bad ref';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
 }

package/dist/server/routes/events.js

@@ -1,11 +1,16 @@
+import { safeSend } from "../utils/sse.js";
 export async function eventRoutes(app, opts) {
     const { eventBus, instanceId } = opts;
     const hello = { instanceId };
     app.get('/api/events', { sse: true }, async (request, reply) => {
         reply.sse.keepAlive();
         await reply.sse.send({ event: 'connected', data: hello });
+        // The client can leave during the await; a later `onClose` would never run.
+        if (!reply.sse.isConnected) {
+            return;
+        }
         const unsubscribe = eventBus.subscribe(event => {
-            void reply.sse.send({
+            safeSend(reply.sse, {
                 event: event.type,
                 data: { reviewId: event.reviewId }
             });

package/dist/server/routes/export.js

@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox';
-import { exportAsJson, exportAsMarkdown, ExportNotFoundError } from "../services/export.service.js";
+import { exportAsJson, exportAsMarkdown } from "../services/export.service.js";
 const ExportParams = Type.Object({ id: Type.String() });
 const ExportQuery = Type.Object({
     format: Type.Union([Type.Literal('json'), Type.Literal('markdown')])
@@ -8,20 +8,11 @@ export async function exportRoutes(app, opts) {
     const { db, repositoryPath } = opts;
     const typedApp = app.withTypeProvider();
     typedApp.get('/api/reviews/:id/export', { schema: { params: ExportParams, querystring: ExportQuery } }, async (request, reply) => {
-        try {
-            if (request.query.format === 'json') {
-                return exportAsJson(db, request.params.id);
-            }
-            const markdown = await exportAsMarkdown(db, request.params.id, repositoryPath);
-            reply.type('text/markdown');
-            return markdown;
-        }
-        catch (error) {
-            if (error instanceof ExportNotFoundError) {
-                reply.code(404);
-                return { error: 'Not Found', message: error.message, statusCode: 404 };
-            }
-            throw error;
+        if (request.query.format === 'json') {
+            return exportAsJson(db, request.params.id);
         }
+        const markdown = await exportAsMarkdown(db, request.params.id, repositoryPath);
+        reply.type('text/markdown');
+        return markdown;
     });
 }

package/dist/server/routes/git.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
 import { getRepositoryInfo, stagePaths, unstagePaths, discardPaths, getFilesAtRef, getFileAtRef } from "../services/git.service.js";
 const TreeParams = Type.Object({
@@ -20,61 +21,52 @@ export async function gitRoutes(app, opts) {
     app.get('/api/git/info', async () => {
         return getRepositoryInfo(repositoryPath);
     });
-    typedApp.post('/api/git/stage', { schema: { body: OptionalPathsBody } }, async (request, reply) => {
+    typedApp.post('/api/git/stage', { schema: { body: OptionalPathsBody } }, async (request) => {
         try {
             await stagePaths(repositoryPath, request.body.paths ?? []);
             return { ok: true };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to stage';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.post('/api/git/unstage', { schema: { body: OptionalPathsBody } }, async (request, reply) => {
+    typedApp.post('/api/git/unstage', { schema: { body: OptionalPathsBody } }, async (request) => {
         try {
             await unstagePaths(repositoryPath, request.body.paths ?? []);
             return { ok: true };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to unstage';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.post('/api/git/discard', { schema: { body: DiscardBody } }, async (request, reply) => {
+    typedApp.post('/api/git/discard', { schema: { body: DiscardBody } }, async (request) => {
         try {
             await discardPaths(repositoryPath, request.body.paths);
             return { ok: true };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to discard changes';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.get('/api/git/tree/:ref', { schema: { params: TreeParams } }, async (request, reply) => {
+    typedApp.get('/api/git/tree/:ref', { schema: { params: TreeParams } }, async (request) => {
         const { ref } = request.params;
         try {
             const files = await getFilesAtRef(repositoryPath, ref);
             return { ref, files };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to list files';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.get('/api/git/file/*', { schema: { querystring: FileContentQuery } }, async (request, reply) => {
+    typedApp.get('/api/git/file/*', { schema: { querystring: FileContentQuery } }, async (request) => {
         const filePath = request.params['*'];
         const { ref } = request.query;
         if (!filePath) {
-            reply.code(400);
-            return {
-                error: 'Bad Request',
-                message: 'File path is required',
-                statusCode: 400
-            };
+            throw new BadRequestError('File path is required');
         }
         let content;
         let isBinary;
@@ -83,9 +75,8 @@ export async function gitRoutes(app, opts) {
             ({ content, isBinary } = await getFileAtRef(repositoryPath, ref, filePath));
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to read file';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
         const lines = isBinary ? [] : content.split('\n');
         return {

package/dist/server/routes/reviews.js

@@ -1,5 +1,6 @@
+import { NotFoundError, BadRequestError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
-import { createReview, getReview, getReviews, setReviewStatus, removeReview, ValidationError } from "../services/review.service.js";
+import { createReview, getReview, getReviews, setReviewStatus, removeReview } from "../services/review.service.js";
 import { getRepositoryInfo } from "../services/git.service.js";
 const CreateReviewBody = Type.Object({
     sourceType: Type.Optional(Type.Union([
@@ -33,22 +34,9 @@ export async function reviewRoutes(app, opts) {
     const { repositoryPath, db, eventBus } = opts;
     const typedApp = app.withTypeProvider();
     typedApp.post('/api/reviews', { schema: { body: CreateReviewBody } }, async (request, reply) => {
-        try {
-            const review = await createReview(db, repositoryPath, request.body, eventBus);
-            reply.code(201);
-            return review;
-        }
-        catch (error) {
-            if (error instanceof ValidationError) {
-                reply.code(400);
-                return {
-                    error: 'Bad Request',
-                    message: error.message,
-                    statusCode: 400
-                };
-            }
-            throw error;
-        }
+        const review = await createReview(db, repositoryPath, request.body, eventBus);
+        reply.code(201);
+        return review;
     });
     typedApp.get('/api/reviews', { schema: { querystring: ReviewsQuery } }, async (request) => {
         const { branch, search, createdFrom, createdTo, files } = request.query;
@@ -63,46 +51,26 @@ export async function reviewRoutes(app, opts) {
                 : undefined
         });
     });
-    typedApp.get('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request, reply) => {
+    typedApp.get('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request) => {
         const review = getReview(db, request.params.id);
         if (!review) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         return review;
     });
-    typedApp.patch('/api/reviews/:id', { schema: { params: ReviewIdParams, body: UpdateReviewBody } }, async (request, reply) => {
+    typedApp.patch('/api/reviews/:id', { schema: { params: ReviewIdParams, body: UpdateReviewBody } }, async (request) => {
         if (!request.body.status) {
-            reply.code(400);
-            return {
-                error: 'Bad Request',
-                message: '"status" is required',
-                statusCode: 400
-            };
+            throw new BadRequestError('"status" is required');
         }
         const updated = setReviewStatus(db, request.params.id, request.body.status, eventBus);
         if (!updated) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         return updated;
     });
     typedApp.delete('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request, reply) => {
         if (!getReview(db, request.params.id)) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         removeReview(db, request.params.id, eventBus);
         reply.code(204);