feat: add parseOpportunityFeedback worker with Bragi integration (#3430)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: rebelchris

.infra/common.ts

@@ -460,6 +460,10 @@ export const workers: Worker[] = [
     topic: 'gondul.v1.opportunity-preview-results',
     subscription: 'api.opportunity-preview-result',
   },
+  {
+    topic: 'api.v1.opportunity-feedback-submitted',
+    subscription: 'api.parse-opportunity-feedback',
+  },
 ];
 
 export const personalizedDigestWorkers: Worker[] = [

__tests__/schema/opportunity.ts

@@ -6445,6 +6445,131 @@ describe('query opportunityStats', () => {
   });
 });
 
+describe('query opportunityFeedback', () => {
+  const OPPORTUNITY_FEEDBACK_QUERY = /* GraphQL */ `
+    query OpportunityFeedback(
+      $opportunityId: ID!
+      $first: Int
+      $after: String
+    ) {
+      opportunityFeedback(
+        opportunityId: $opportunityId
+        first: $first
+        after: $after
+      ) {
+        pageInfo {
+          hasNextPage
+          endCursor
+          totalCount
+        }
+        edges {
+          node {
+            platform
+            category
+            sentiment
+            urgency
+            screening
+            answer
+          }
+        }
+      }
+    }
+  `;
+
+  it('should return only feedback with recruiter platform classification', async () => {
+    loggedUser = '1';
+
+    // Create matches with different feedback platforms
+    await con.getRepository(OpportunityMatch).save([
+      {
+        opportunityId: opportunitiesFixture[0].id,
+        userId: usersFixture[1].id,
+        status: OpportunityMatchStatus.CandidateAccepted,
+        description: { reasoning: 'Test' },
+        feedback: [
+          {
+            screening: 'What interests you?',
+            answer: 'The tech stack looks great',
+            classification: {
+              platform: 2, // RECRUITER - should be returned
+              category: 1,
+              sentiment: 1,
+              urgency: 2,
+            },
+          },
+          {
+            screening: 'Internal feedback',
+            answer: 'Platform seems slow',
+            classification: {
+              platform: 1, // DAILY_DEV - should NOT be returned
+              category: 2,
+              sentiment: 0,
+              urgency: 1,
+            },
+          },
+        ],
+      },
+      {
+        opportunityId: opportunitiesFixture[0].id,
+        userId: usersFixture[2].id,
+        status: OpportunityMatchStatus.CandidateAccepted,
+        description: { reasoning: 'Test 2' },
+        feedback: [
+          {
+            screening: 'Salary expectations?',
+            answer: 'Looking for 150k+',
+            classification: {
+              platform: 2, // RECRUITER - should be returned
+              category: 3,
+              sentiment: 0,
+              urgency: 1,
+            },
+          },
+          {
+            screening: 'Unclassified feedback',
+            answer: 'No classification yet',
+            // No classification - should NOT be returned
+          },
+        ],
+      },
+    ]);
+
+    const res = await client.query(OPPORTUNITY_FEEDBACK_QUERY, {
+      variables: { opportunityId: opportunitiesFixture[0].id, first: 10 },
+    });
+
+    expect(res.errors).toBeFalsy();
+    expect(res.data.opportunityFeedback.pageInfo.totalCount).toBe(2);
+    expect(res.data.opportunityFeedback.edges).toHaveLength(2);
+
+    // Verify all returned feedback has recruiter platform
+    const platforms = res.data.opportunityFeedback.edges.map(
+      (e: { node: { platform: number } }) => e.node.platform,
+    );
+    expect(platforms).toEqual([2, 2]);
+
+    // Verify the answers match expected recruiter feedback
+    const answers = res.data.opportunityFeedback.edges.map(
+      (e: { node: { answer: string } }) => e.node.answer,
+    );
+    expect(answers).toContain('The tech stack looks great');
+    expect(answers).toContain('Looking for 150k+');
+    expect(answers).not.toContain('Platform seems slow'); // DAILY_DEV feedback
+    expect(answers).not.toContain('No classification yet'); // Unclassified feedback
+  });
+
+  it('should deny access if user is not a recruiter for the opportunity', async () => {
+    loggedUser = '3'; // User 3 is not a recruiter for opportunity 0
+
+    const res = await client.query(OPPORTUNITY_FEEDBACK_QUERY, {
+      variables: { opportunityId: opportunitiesFixture[0].id },
+    });
+
+    expect(res.errors).toBeTruthy();
+    expect(res.errors[0].extensions.code).toBe('FORBIDDEN');
+  });
+});
+
 describe('mutation reimportOpportunity', () => {
   const MUTATION = /* GraphQL */ `
     mutation ReimportOpportunity($payload: ReimportOpportunityInput!) {

__tests__/workers/opportunity/parseOpportunityFeedback.ts

@@ -0,0 +1,147 @@
+import { expectSuccessfulTypedBackground, saveFixtures } from '../../helpers';
+import { parseOpportunityFeedbackWorker as worker } from '../../../src/workers/opportunity/parseOpportunityFeedback';
+import { DataSource } from 'typeorm';
+import createOrGetConnection from '../../../src/db';
+import { OpportunityMatch } from '../../../src/entity/OpportunityMatch';
+import { User } from '../../../src/entity';
+import { usersFixture } from '../../fixture';
+import { OpportunityMatchStatus } from '../../../src/entity/opportunities/types';
+import {
+  FeedbackCategory,
+  FeedbackPlatform,
+  FeedbackSentiment,
+  FeedbackUrgency,
+  OpportunityState,
+  OpportunityType,
+} from '@dailydotdev/schema';
+
+const mockParseFeedback = jest.fn();
+
+jest.mock('../../../src/integrations/bragi', () => ({
+  getBragiClient: () => ({
+    garmr: {
+      execute: (fn: () => Promise<unknown>) => fn(),
+    },
+    instance: {
+      parseFeedback: (...args: unknown[]) => mockParseFeedback(...args),
+    },
+  }),
+}));
+
+let con: DataSource;
+const testOpportunityId = '550e8400-e29b-41d4-a716-446655440099';
+
+beforeAll(async () => {
+  con = await createOrGetConnection();
+});
+
+beforeEach(async () => {
+  jest.resetAllMocks();
+  await saveFixtures(con, User, usersFixture);
+
+  // Create a minimal opportunity record
+  await con.query(
+    `INSERT INTO opportunity (id, type, state, title, tldr, content, meta)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     ON CONFLICT (id) DO NOTHING`,
+    [
+      testOpportunityId,
+      OpportunityType.JOB,
+      OpportunityState.LIVE,
+      'Test Opportunity',
+      'Test TLDR',
+      JSON.stringify({}),
+      JSON.stringify({}),
+    ],
+  );
+});
+
+afterEach(async () => {
+  await con
+    .getRepository(OpportunityMatch)
+    .delete({ opportunityId: testOpportunityId });
+});
+
+afterAll(async () => {
+  await con.query('DELETE FROM opportunity WHERE id = $1', [testOpportunityId]);
+});
+
+describe('parseOpportunityFeedback worker', () => {
+  it('should skip when no match is found', async () => {
+    await expectSuccessfulTypedBackground<'api.v1.opportunity-feedback-submitted'>(
+      worker,
+      {
+        opportunityId: testOpportunityId,
+        userId: 'nonexistent-user',
+      },
+    );
+
+    expect(mockParseFeedback).not.toHaveBeenCalled();
+  });
+
+  it('should skip when match has no feedback', async () => {
+    await con.getRepository(OpportunityMatch).save({
+      opportunityId: testOpportunityId,
+      userId: '1',
+      status: OpportunityMatchStatus.Pending,
+      description: { reasoning: 'Test match' },
+      feedback: [],
+    });
+
+    await expectSuccessfulTypedBackground<'api.v1.opportunity-feedback-submitted'>(
+      worker,
+      {
+        opportunityId: testOpportunityId,
+        userId: '1',
+      },
+    );
+
+    expect(mockParseFeedback).not.toHaveBeenCalled();
+  });
+
+  it('should parse feedback and store classification in database', async () => {
+    await con.getRepository(OpportunityMatch).save({
+      opportunityId: testOpportunityId,
+      userId: '2',
+      status: OpportunityMatchStatus.Pending,
+      description: { reasoning: 'Test match' },
+      feedback: [{ question: 'How was it?', answer: 'Great experience!' }],
+    });
+
+    mockParseFeedback.mockResolvedValue({
+      classification: {
+        platform: FeedbackPlatform.RECRUITER,
+        category: FeedbackCategory.FEATURE_REQUEST,
+        sentiment: FeedbackSentiment.POSITIVE,
+        urgency: FeedbackUrgency.LOW,
+      },
+    });
+
+    await expectSuccessfulTypedBackground<'api.v1.opportunity-feedback-submitted'>(
+      worker,
+      {
+        opportunityId: testOpportunityId,
+        userId: '2',
+      },
+    );
+
+    expect(mockParseFeedback).toHaveBeenCalledWith({
+      feedback: 'Great experience!',
+    });
+
+    // Verify the classification was stored correctly in the database
+    const updatedMatch = await con.getRepository(OpportunityMatch).findOne({
+      where: {
+        opportunityId: testOpportunityId,
+        userId: '2',
+      },
+    });
+
+    expect(updatedMatch?.feedback?.[0]?.classification).toEqual({
+      platform: FeedbackPlatform.RECRUITER,
+      category: FeedbackCategory.FEATURE_REQUEST,
+      sentiment: FeedbackSentiment.POSITIVE,
+      urgency: FeedbackUrgency.LOW,
+    });
+  });
+});

package.json

@@ -36,7 +36,7 @@
     "@connectrpc/connect-fastify": "^1.6.1",
     "@connectrpc/connect-node": "^1.6.1",
     "@dailydotdev/graphql-redis-subscriptions": "^2.4.3",
-    "@dailydotdev/schema": "0.2.64",
+    "@dailydotdev/schema": "0.2.65",
     "@dailydotdev/ts-ioredis-pool": "^1.0.2",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",

pnpm-lock.yaml

@@ -585,3 +585,18 @@ export const notifyOpportunityMatchCandidateReview = async ({
     topic: 'api.v1.candidate-review-opportunity',
   });
 };
+
+export const notifyOpportunityFeedbackSubmitted = async ({
+  logger,
+  opportunityId,
+  userId,
+}: {
+  logger: FastifyBaseLogger;
+  opportunityId: string;
+  userId: string;
+}) => {
+  await triggerTypedEvent(logger, 'api.v1.opportunity-feedback-submitted', {
+    opportunityId,
+    userId,
+  });
+};

src/common/opportunity/pubsub.ts

@@ -1,5 +1,23 @@
 import z from 'zod';
 
+export const feedbackClassificationSchema = z.object({
+  platform: z.number(),
+  category: z.number(),
+  sentiment: z.number(),
+  urgency: z.number(),
+});
+
+export const opportunityFeedbackSchema = z.object({
+  screening: z.string(),
+  answer: z.string(),
+  classification: feedbackClassificationSchema.optional(),
+});
+
+export type OpportunityFeedback = z.infer<typeof opportunityFeedbackSchema>;
+export type FeedbackClassification = z.infer<
+  typeof feedbackClassificationSchema
+>;
+
 export const opportunityScreeningAnswersSchema = z.object({
   id: z.uuid(),
   answers: z

src/common/schema/opportunityMatch.ts

@@ -246,6 +246,10 @@ export type PubSubSchema = {
   'gondul.v1.warm-intro-generated': WarmIntro;
   'api.v1.user-profile-updated': UserProfileUpdatedMessage;
   'gondul.v1.opportunity-preview-results': OpportunityPreviewResult;
+  'api.v1.opportunity-feedback-submitted': {
+    opportunityId: string;
+    userId: string;
+  };
 };
 
 export async function triggerTypedEvent<T extends keyof PubSubSchema>(