@shipfox/annotations 18.0.0 → 20.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/annotations",
   "license": "MIT",
-  "version": "18.0.0",
+  "version": "20.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -20,13 +20,13 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/annotations-dto": "12.3.0",
-    "@shipfox/api-auth-context": "18.0.0",
+    "@shipfox/annotations-dto": "19.0.0",
+    "@shipfox/api-auth-context": "20.0.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.3",
     "@shipfox/node-drizzle": "0.3.5",
     "@shipfox/node-fastify": "0.4.3",
-    "@shipfox/node-module": "1.0.7",
+    "@shipfox/node-module": "1.0.8",
     "@shipfox/node-postgres": "0.5.1"
   },
   "imports": {

package/src/core/write-annotations.ts

@@ -1,6 +1,10 @@
 import type {LeasedWriteAnnotationOperationDto} from '@shipfox/annotations-dto';
 import {config} from '#config.js';
-import {type StoredAnnotation, withAnnotationLock} from '#db/annotations.js';
+import {
+  type AnnotationWriteRepository,
+  type StoredAnnotation,
+  withAnnotationLock,
+} from '#db/annotations.js';
 import {
   AnnotationBodyTooLargeError,
   AnnotationCountLimitExceededError,
@@ -28,88 +32,97 @@ export interface WriteAnnotationsResult {
   };
 }
 
-export function writeAnnotations(params: WriteAnnotationsParams): Promise<WriteAnnotationsResult> {
-  return withAnnotationLock(params.jobExecutionId, async (repo) => {
-    const current = await repo.loadCurrentAnnotations(params.jobExecutionId);
-    let nextSequence =
-      Math.max(0, ...Array.from(current.values()).map((annotation) => annotation.sequence)) + 1;
-    const results: WriteAnnotationsResult['annotations'] = [];
+interface AnnotationWriteState {
+  current: Map<string, StoredAnnotation>;
+  nextSequence: number;
+  results: WriteAnnotationsResult['annotations'];
+}
 
-    for (const operation of params.operations) {
-      if (operation.op === 'remove') {
-        await repo.removeAnnotation(params.jobExecutionId, operation.context);
-        current.delete(operation.context);
-        results.push({context: operation.context, id: null});
-        continue;
-      }
+async function applyAnnotationOperation(
+  repo: AnnotationWriteRepository,
+  params: WriteAnnotationsParams,
+  operation: LeasedWriteAnnotationOperationDto,
+  state: AnnotationWriteState,
+): Promise<void> {
+  if (operation.op === 'remove') {
+    await repo.removeAnnotation(params.jobExecutionId, operation.context);
+    state.current.delete(operation.context);
+    state.results.push({context: operation.context, id: null});
+    return;
+  }
 
-      const existing = current.get(operation.context);
-      const body =
-        operation.op === 'append' ? `${existing?.body ?? ''}${operation.body}` : operation.body;
-      const bodyBytes = Buffer.byteLength(body);
-      ensureBodyBudget(bodyBytes);
+  const existing = state.current.get(operation.context);
+  const body =
+    operation.op === 'append' ? `${existing?.body ?? ''}${operation.body}` : operation.body;
+  const bodyBytes = Buffer.byteLength(body);
+  ensureBodyBudget(bodyBytes);
+  const unchanged =
+    operation.op === 'replace' &&
+    existing !== undefined &&
+    existing.body === body &&
+    existing.style === operation.style;
+  if (unchanged) {
+    state.results.push({context: operation.context, id: existing.id});
+    return;
+  }
 
-      const isUnchangedReplace =
-        operation.op === 'replace' &&
-        existing !== undefined &&
-        existing.body === body &&
-        existing.style === operation.style;
-      if (isUnchangedReplace) {
-        results.push({context: operation.context, id: existing.id});
-        continue;
-      }
+  const draft = new Map(state.current);
+  draft.set(operation.context, {
+    id: existing?.id ?? '',
+    context: operation.context,
+    style: operation.style,
+    body,
+    bodyBytes,
+    sequence: existing?.sequence ?? state.nextSequence,
+  });
+  ensureExecutionBudgets(draft);
 
-      const draft = new Map(current);
-      draft.set(operation.context, {
-        id: existing?.id ?? '',
+  const row = existing
+    ? await repo.updateAnnotation({
+        id: existing.id,
+        originStepId: params.originStepId,
+        originStepAttempt: params.originStepAttempt,
+        style: operation.style,
+        body,
+        bodyBytes,
+      })
+    : await repo.createAnnotation({
+        workspaceId: params.workspaceId,
+        projectId: params.projectId,
+        workflowRunId: params.workflowRunId,
+        workflowRunAttempt: params.workflowRunAttempt,
+        workflowRunAttemptId: params.workflowRunAttemptId,
+        jobId: params.jobId,
+        jobExecutionId: params.jobExecutionId,
+        originStepId: params.originStepId,
+        originStepAttempt: params.originStepAttempt,
         context: operation.context,
         style: operation.style,
         body,
         bodyBytes,
-        sequence: existing?.sequence ?? nextSequence,
+        sequence: state.nextSequence,
       });
-      ensureExecutionBudgets(draft);
+  state.current.set(operation.context, row);
+  if (!existing) state.nextSequence += 1;
+  state.results.push({context: operation.context, id: row.id});
+}
 
-      const row = existing
-        ? await repo.updateAnnotation({
-            id: existing.id,
-            originStepId: params.originStepId,
-            originStepAttempt: params.originStepAttempt,
-            style: operation.style,
-            body,
-            bodyBytes,
-          })
-        : await repo.createAnnotation({
-            workspaceId: params.workspaceId,
-            projectId: params.projectId,
-            workflowRunId: params.workflowRunId,
-            workflowRunAttempt: params.workflowRunAttempt,
-            workflowRunAttemptId: params.workflowRunAttemptId,
-            jobId: params.jobId,
-            jobExecutionId: params.jobExecutionId,
-            originStepId: params.originStepId,
-            originStepAttempt: params.originStepAttempt,
-            context: operation.context,
-            style: operation.style,
-            body,
-            bodyBytes,
-            sequence: nextSequence,
-          });
+export function writeAnnotations(params: WriteAnnotationsParams): Promise<WriteAnnotationsResult> {
+  return withAnnotationLock(params.jobExecutionId, async (repo) => {
+    const current = await repo.loadCurrentAnnotations(params.jobExecutionId);
+    const state: AnnotationWriteState = {
+      current,
+      nextSequence:
+        Math.max(0, ...Array.from(current.values()).map((annotation) => annotation.sequence)) + 1,
+      results: [],
+    };
 
-      current.set(operation.context, {
-        id: row.id,
-        context: row.context,
-        style: row.style,
-        body: row.body,
-        bodyBytes: row.bodyBytes,
-        sequence: row.sequence,
-      });
-      if (!existing) nextSequence += 1;
-      results.push({context: operation.context, id: row.id});
+    for (const operation of params.operations) {
+      await applyAnnotationOperation(repo, params, operation, state);
     }
 
     return {
-      annotations: results,
+      annotations: state.results,
       accounting: currentAccounting(current),
     };
   });

package/src/presentation/inter-module.test.ts

@@ -8,6 +8,7 @@ import {
 } from '#core/errors.js';
 import {db} from '#db/db.js';
 import {annotations} from '#db/schema/annotations.js';
+import {annotationFactory} from '#test/index.js';
 import {
   createAnnotationsInterModulePresentation,
   toReplaceOrRemoveAnnotationKnownError,
@@ -29,6 +30,75 @@ function input() {
 }
 
 describe('Annotations inter-module presentation', () => {
+  test('lists only annotations owned by the requested workspace with pagination', async () => {
+    const workspaceId = crypto.randomUUID();
+    const workflowRunId = crypto.randomUUID();
+    const visible = await annotationFactory.create({
+      workspaceId,
+      workflowRunId,
+      context: 'visible',
+      sequence: 1,
+    });
+    const next = await annotationFactory.create({
+      workspaceId,
+      workflowRunId,
+      context: 'next',
+      sequence: 2,
+    });
+    await annotationFactory.create({
+      workspaceId,
+      workflowRunId,
+      context: 'after',
+      sequence: 3,
+    });
+    await annotationFactory.create({
+      workspaceId: crypto.randomUUID(),
+      workflowRunId,
+      context: 'hidden',
+      sequence: 4,
+    });
+    const presentation = createAnnotationsInterModulePresentation();
+
+    const result = await presentation.handlers.listAnnotationsForRunAttempt(
+      {
+        workspaceId,
+        workflowRunId,
+        workflowRunAttempt: 1,
+        limit: 2,
+      },
+      {signal: new AbortController().signal},
+    );
+
+    expect(result).toEqual({
+      annotations: [
+        {
+          id: visible.id,
+          job_id: visible.jobId,
+          job_execution_id: visible.jobExecutionId,
+          origin_step_id: visible.originStepId,
+          origin_step_attempt: visible.originStepAttempt,
+          context: 'visible',
+          style: visible.style,
+          sequence: 1,
+          body: visible.body,
+        },
+        {
+          id: next.id,
+          job_id: next.jobId,
+          job_execution_id: next.jobExecutionId,
+          origin_step_id: next.originStepId,
+          origin_step_attempt: next.originStepAttempt,
+          context: 'next',
+          style: next.style,
+          sequence: 2,
+          body: next.body,
+        },
+      ],
+      hasMore: true,
+      nextCursor: {value: next.sequence, id: next.id},
+    });
+  });
+
   test('replaces and removes a warning annotation through PostgreSQL', async () => {
     const presentation = createAnnotationsInterModulePresentation();
     const target = input();

package/src/presentation/inter-module.ts

@@ -10,6 +10,8 @@ import {
   AnnotationTotalBytesLimitExceededError,
 } from '#core/errors.js';
 import {writeAnnotations} from '#core/write-annotations.js';
+import {listAnnotationsForRunAttempt} from '#db/index.js';
+import {toAnnotationDto} from './dto/annotation.js';
 
 export function createAnnotationsInterModulePresentation(): InterModulePresentation<
   typeof annotationsInterModuleContract
@@ -31,6 +33,24 @@ export function createAnnotationsInterModulePresentation(): InterModulePresentat
         throw toReplaceOrRemoveAnnotationKnownError(error);
       }
     },
+    listAnnotationsForRunAttempt: async (input) => {
+      const result = await listAnnotationsForRunAttempt({
+        workflowRunId: input.workflowRunId,
+        workflowRunAttempt: input.workflowRunAttempt,
+        workspaceIds: [input.workspaceId],
+        jobExecutionId: input.jobExecutionId,
+        after: input.cursor ? {sequence: input.cursor.value, id: input.cursor.id} : undefined,
+        limit: input.limit,
+      });
+
+      return {
+        annotations: result.annotations.map(toAnnotationDto),
+        hasMore: result.hasMore,
+        nextCursor: result.nextCursor
+          ? {value: result.nextCursor.sequence, id: result.nextCursor.id}
+          : null,
+      };
+    },
   });
 }
 

package/src/presentation/routes/read-annotations.test.ts

@@ -5,6 +5,12 @@ import {annotationFactory} from '#test/index.js';
 import {readAnnotationSummaryRoute} from './read-annotation-summary.js';
 import {readAnnotationsRoute} from './read-annotations.js';
 
+function workspaceStatus(value: string | undefined): 'active' | 'suspended' | 'deleted' {
+  if (value === 'suspended') return 'suspended';
+  if (value === 'deleted') return 'deleted';
+  return 'active';
+}
+
 const fakeUserAuth: AuthMethod = {
   name: AUTH_USER,
   authenticate: (request: FastifyRequest) => {
@@ -20,9 +26,7 @@ const fakeUserAuth: AuthMethod = {
       .map((value) => {
         const [workspaceId, status] = value.split('|');
         if (!workspaceId) throw new Error('missing test workspace id');
-        const workspaceStatus: 'active' | 'suspended' | 'deleted' =
-          status === 'suspended' ? 'suspended' : status === 'deleted' ? 'deleted' : 'active';
-        return {workspaceId, role: 'admin' as const, workspaceStatus};
+        return {workspaceId, role: 'admin' as const, workspaceStatus: workspaceStatus(status)};
       });
 
     setUserContext(