@plandesk/api 0.10.0 → 0.13.1

package/dist/routes/comments.js

@@ -12,6 +12,7 @@ async function handleCreateComment(c, commentService, target) {
         const comment = commentService.create(target, {
             body: body.body,
             passage: body.passage,
+            anchor: body.anchor,
         });
         if (!comment) {
             return c.json({ error: 'not_found' }, 404);
@@ -51,6 +52,46 @@ export function createCommentsRouter(commentService) {
         }
         return c.json(comments);
     });
+    // Artifact comments are project-scoped. The file identity (content-hash+path,
+    // which may contain slashes) travels in the JSON body / query, not a path
+    // segment, so it never collides with routing.
+    router.post('/projects/:id/artifact-comments', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.body !== 'string' || typeof body.artifact_id !== 'string') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const comment = commentService.createForArtifact(c.req.param('id'), body.artifact_id, {
+                body: body.body,
+                passage: body.passage,
+                anchor: body.anchor,
+            });
+            if (!comment) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(comment, 201);
+        }
+        catch (error) {
+            if (error instanceof InvalidCommentError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.get('/projects/:id/artifact-comments', (c) => {
+        const artifactId = c.req.query('artifact_id');
+        if (artifactId === undefined || artifactId === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        const includeResolved = parseIncludeResolved(c.req.query('include_resolved'));
+        const comments = commentService.listForArtifact(c.req.param('id'), artifactId, {
+            includeResolved,
+        });
+        if (!comments) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(comments);
+    });
     router.patch('/comments/:id', async (c) => {
         const body = await c.req.json();
         try {

package/dist/serialize.d.ts

@@ -95,6 +95,7 @@ export type SerializedComment = {
     target_id: string;
     document_id: string | null;
     passage: string | null;
+    anchor: string | null;
     body: string;
     resolved: boolean;
     created_at: string;

package/dist/serialize.js

@@ -127,6 +127,7 @@ export function serializeComment(comment) {
         target_id: comment.targetId,
         document_id: comment.targetType === 'document' ? comment.targetId : null,
         passage: comment.passage,
+        anchor: comment.anchor,
         body: comment.body,
         resolved: comment.resolved,
         created_at: comment.createdAt.toISOString(),

package/dist/services/comments.d.ts

@@ -12,6 +12,7 @@ export type CommentTarget = {
 export type CreateCommentInput = {
     body: string;
     passage?: string | null;
+    anchor?: string | null;
 };
 export type UpdateCommentInput = {
     body?: string;
@@ -22,6 +23,10 @@ export declare class InvalidCommentError extends Error {
 }
 export declare function createCommentService(deps: CommentServiceDeps): {
     create(target: CommentTarget, input: CreateCommentInput): SerializedComment | undefined;
+    createForArtifact(projectId: string, artifactId: string, input: CreateCommentInput): SerializedComment | undefined;
+    listForArtifact(projectId: string, artifactId: string, options?: {
+        includeResolved?: boolean;
+    }): SerializedComment[] | undefined;
     listByTarget(target: CommentTarget, options?: {
         includeResolved?: boolean;
     }): SerializedComment[] | undefined;

package/dist/services/comments.js

@@ -21,6 +21,11 @@ function targetProjectId(db, target) {
             return dbGetNote(db, target.id)?.projectId;
         case 'submission':
             return getSubmission(db, target.id)?.projectId;
+        case 'artifact':
+            // An artifact is a file on disk, not a DB entity — its project is
+            // supplied by the caller (the connected repo's project), not resolved
+            // from the target id. Artifact comments go through createForArtifact.
+            return undefined;
     }
 }
 function emitCommentCreated(eventBus, commentId, projectId, target) {
@@ -58,10 +63,40 @@ export function createCommentService(deps) {
                 targetId: target.id,
                 body: input.body,
                 passage: input.passage,
+                anchor: input.anchor,
             });
             emitCommentCreated(eventBus, comment.id, projectId, target);
             return serializeComment(comment);
         },
+        // Artifact comments are project-scoped: the caller supplies the project
+        // (the connected repo's), and the file identity is the target id. Slashes
+        // in the file identity mean it travels in the body/query, never a path seg.
+        createForArtifact(projectId, artifactId, input) {
+            if (!getProject(db, projectId)) {
+                return undefined;
+            }
+            if (artifactId.trim() === '') {
+                throw new InvalidCommentError('Artifact id must not be empty');
+            }
+            assertNonEmptyBody(input.body);
+            const target = { type: 'artifact', id: artifactId };
+            const comment = createComment(db, {
+                projectId,
+                targetType: 'artifact',
+                targetId: artifactId,
+                body: input.body,
+                passage: input.passage,
+                anchor: input.anchor,
+            });
+            emitCommentCreated(eventBus, comment.id, projectId, target);
+            return serializeComment(comment);
+        },
+        listForArtifact(projectId, artifactId, options) {
+            if (!getProject(db, projectId)) {
+                return undefined;
+            }
+            return dbListCommentsByTarget(db, 'artifact', artifactId, options).map(serializeComment);
+        },
         listByTarget(target, options) {
             const projectId = targetProjectId(db, target);
             if (!projectId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plandesk/api",
-  "version": "0.10.0",
+  "version": "0.13.1",
   "type": "module",
   "exports": {
     ".": {
@@ -18,8 +18,8 @@
   "devDependencies": {
     "typescript": "^6.0.3",
     "vitest": "^3.2.6",
-    "@plandesk/db": "0.8.0",
-    "@plandesk/sync-server": "0.5.0"
+    "@plandesk/db": "0.13.1",
+    "@plandesk/sync-server": "0.13.1"
   },
   "dependencies": {
     "@hono/node-server": "^2.0.4",