@shipfox/api-workflows 2.0.0

package/src/presentation/routes/get-run-aggregates.test.ts

@@ -0,0 +1,114 @@
+import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {FastifyInstance} from 'fastify';
+import Fastify from 'fastify';
+import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {createWorkflowRun, updateWorkflowRunStatus} from '#db/workflow-runs.js';
+import {workflowModel} from '#test/index.js';
+import {getRunAggregatesRoute} from './get-run-aggregates.js';
+
+const projectAccessState = vi.hoisted(() => ({workspaceId: ''}));
+
+vi.mock('@shipfox/api-projects', () => ({
+  ProjectNotFoundError: class ProjectNotFoundError extends Error {},
+  requireProjectAccess: vi.fn(({projectId}) =>
+    Promise.resolve({
+      project: {id: projectId, workspaceId: projectAccessState.workspaceId},
+      workspaceId: projectAccessState.workspaceId,
+    }),
+  ),
+}));
+
+describe('GET /api/workflows/runs/aggregates', () => {
+  let app: FastifyInstance;
+  let workspaceId: string;
+  let projectId: string;
+
+  beforeAll(async () => {
+    app = Fastify();
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+    app.addHook('onRequest', (request, _reply, done) => {
+      setUserContext(
+        request,
+        buildUserContext({
+          userId: crypto.randomUUID(),
+          email: 'user@example.com',
+          memberships: [{workspaceId, role: 'admin'}],
+        }),
+      );
+      done();
+    });
+    app.get('/api/workflows/runs/aggregates', getRunAggregatesRoute);
+    await app.ready();
+  });
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    projectId = crypto.randomUUID();
+    projectAccessState.workspaceId = workspaceId;
+  });
+
+  test('returns faceted counts that ignore only their own selected filter', async () => {
+    const deployDefinitionId = crypto.randomUUID();
+    const nightlyDefinitionId = crypto.randomUUID();
+    const succeeded = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: deployDefinitionId,
+      name: 'Deploy',
+      model: workflowModel({name: 'Deploy'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    await updateWorkflowRunStatus({
+      workflowRunId: succeeded.id,
+      status: 'succeeded',
+      expectedVersion: succeeded.version,
+    });
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: deployDefinitionId,
+      name: 'Deploy',
+      model: workflowModel({name: 'Deploy'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: nightlyDefinitionId,
+      name: 'Nightly',
+      model: workflowModel({name: 'Nightly'}),
+      triggerPayload: {
+        source: 'cron',
+        event: 'tick',
+        scheduleId: crypto.randomUUID(),
+      },
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs/aggregates?project_id=${projectId}&status=succeeded&trigger_source=manual`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.status).toEqual(
+      expect.arrayContaining([
+        {value: 'pending', count: 1},
+        {value: 'succeeded', count: 1},
+      ]),
+    );
+    expect(body.trigger_source).toEqual([{value: 'manual', count: 1}]);
+    expect(body.workflow).toEqual([{value: deployDefinitionId, count: 1}]);
+  });
+});

package/src/presentation/routes/get-run-aggregates.ts

@@ -0,0 +1,69 @@
+import {ProjectNotFoundError, requireProjectAccess} from '@shipfox/api-projects';
+import {
+  workflowRunAggregatesQuerySchema,
+  workflowRunAggregatesResponseSchema,
+} from '@shipfox/api-workflows-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {logger} from '@shipfox/node-opentelemetry';
+import {getWorkflowRunAggregates} from '#db/index.js';
+
+export const getRunAggregatesRoute = defineRoute({
+  method: 'GET',
+  path: '/aggregates',
+  description: 'Get faceted workflow run counts for a project',
+  schema: {
+    querystring: workflowRunAggregatesQuerySchema,
+    response: {
+      200: workflowRunAggregatesResponseSchema,
+    },
+  },
+  errorHandler: (error) => {
+    if (error instanceof ProjectNotFoundError) {
+      throw new ClientError(error.message, 'project-not-found', {status: 404});
+    }
+    throw error;
+  },
+  handler: async (request) => {
+    const startedAt = performance.now();
+    const {
+      project_id: projectId,
+      status,
+      definition_id: definitionId,
+      trigger_source: triggerSource,
+      created_from: createdFrom,
+      created_to: createdTo,
+    } = request.query;
+
+    const {project} = await requireProjectAccess({request, projectId});
+    const filters = {
+      status,
+      definitionId,
+      triggerSource,
+      createdFrom: createdFrom ? new Date(createdFrom) : undefined,
+      createdTo: createdTo ? new Date(createdTo) : undefined,
+    };
+    const aggregates = await getWorkflowRunAggregates({projectId: project.id, filters});
+
+    logger().info(
+      {
+        projectId: project.id,
+        filterKeys: Object.entries(filters)
+          .filter(([, value]) => value !== undefined)
+          .map(([key]) => key),
+        aggregateBucketSizes: {
+          status: aggregates.status.length,
+          triggerSource: aggregates.triggerSource.length,
+          workflow: aggregates.workflow.length,
+        },
+        durationMs: Math.round(performance.now() - startedAt),
+      },
+      'Aggregated workflow runs',
+    );
+
+    return {
+      status: aggregates.status,
+      trigger_source: aggregates.triggerSource,
+      workflow: aggregates.workflow,
+    };
+  },
+});