Merge pull request #110 from sudo-robi/feature/bulk-operations

Add bulk verification endpoints

Author: Smartdevs17

README.md

@@ -39,9 +39,16 @@ Rust-based smart contracts deployed on **Stellar Testnet** via Soroban. Features
 Express.js API server providing:
 
 - **AI Work Verification** — Validates freelancer deliverables against project requirements using AI
+- **Bulk Verification Operations** — Batch verify, update, and delete verification records
 - **AI Invoice Generation** — Automated invoice creation for completed work
 - **Stellar Horizon Integration** — On-chain payment status and transaction lookups
 
+### Bulk Verification Endpoints
+
+- `POST /api/v1/verification/verify/batch`
+- `PATCH /api/v1/verification/batch`
+- `DELETE /api/v1/verification/batch`
+
 ## Features
 
 - **Instant Payments** — Funds released immediately upon work approval via Soroban

backend/src/routes/verification.ts

@@ -1,5 +1,10 @@
 import { Router } from 'express';
-import { verifyWork, getVerification } from '../services/verification.js';
+import {
+  verifyWork,
+  getVerification,
+  updateVerification,
+  deleteVerification,
+} from '../services/verification.js';
 import { idempotency } from '../middleware/idempotency.js';
 
 export const verificationRouter = Router();
@@ -22,6 +27,130 @@ verificationRouter.post('/verify', idempotency(), async (req, res) => {
   }
 });
 
+// Bulk AI-powered work verification
+verificationRouter.post('/verify/batch', idempotency(), async (req, res) => {
+  try {
+    const { items } = req.body as {
+      items?: Array<{ repositoryUrl?: string; milestoneDescription?: string; projectId?: string }>;
+    };
+
+    if (!Array.isArray(items) || items.length === 0) {
+      res.status(400).json({ message: 'Missing items for bulk verification' });
+      return;
+    }
+
+    const results = await Promise.all(
+      items.map(async (item, index) => {
+        if (!item?.repositoryUrl || !item?.milestoneDescription || !item?.projectId) {
+          return { index, status: 'error', error: 'Missing required fields' };
+        }
+
+        try {
+          const data = await verifyWork({
+            repositoryUrl: item.repositoryUrl,
+            milestoneDescription: item.milestoneDescription,
+            projectId: item.projectId,
+          });
+          return { index, status: 'success', data };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : 'Verification failed';
+          return { index, status: 'error', error: message };
+        }
+      })
+    );
+
+    res.json({ results });
+  } catch (error) {
+    console.error('Bulk verification error:', error);
+    res.status(500).json({ message: 'Bulk verification failed' });
+  }
+});
+
+// Bulk update verification results
+verificationRouter.patch('/batch', (req, res) => {
+  try {
+    const { items } = req.body as {
+      items?: Array<{
+        id?: string;
+        status?: 'passed' | 'failed' | 'pending';
+        score?: number;
+        summary?: string;
+        details?: string[];
+      }>;
+    };
+
+    if (!Array.isArray(items) || items.length === 0) {
+      res.status(400).json({ message: 'Missing items for bulk update' });
+      return;
+    }
+
+    const results = items.map((item, index) => {
+      if (!item?.id) {
+        return { index, status: 'error', error: 'Missing verification id' };
+      }
+
+      const hasUpdates =
+        item.status !== undefined ||
+        item.score !== undefined ||
+        item.summary !== undefined ||
+        item.details !== undefined;
+
+      if (!hasUpdates) {
+        return { index, status: 'error', error: 'No update fields provided' };
+      }
+
+      const updated = updateVerification({
+        id: item.id,
+        status: item.status,
+        score: item.score,
+        summary: item.summary,
+        details: item.details,
+      });
+
+      if (!updated) {
+        return { index, status: 'error', error: 'Verification not found' };
+      }
+
+      return { index, status: 'success', data: updated };
+    });
+
+    const updatedCount = results.filter((result) => result.status === 'success').length;
+    res.json({ results, updatedCount });
+  } catch (error) {
+    console.error('Bulk update error:', error);
+    res.status(500).json({ message: 'Bulk update failed' });
+  }
+});
+
+// Bulk delete verification results
+verificationRouter.delete('/batch', (req, res) => {
+  try {
+    const { ids } = req.body as { ids?: string[] };
+
+    if (!Array.isArray(ids) || ids.length === 0) {
+      res.status(400).json({ message: 'Missing ids for bulk delete' });
+      return;
+    }
+
+    const results = ids.map((id) => {
+      if (!id) {
+        return { id, status: 'error', error: 'Missing verification id' };
+      }
+
+      const deleted = deleteVerification(id);
+      return deleted
+        ? { id, status: 'deleted' }
+        : { id, status: 'not_found' };
+    });
+
+    const deletedCount = results.filter((result) => result.status === 'deleted').length;
+    res.json({ results, deletedCount });
+  } catch (error) {
+    console.error('Bulk delete error:', error);
+    res.status(500).json({ message: 'Bulk delete failed' });
+  }
+});
+
 // Get verification result by ID
 verificationRouter.get('/:id', async (req, res) => {
   try {

backend/src/services/__tests__/verification-bulk.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import {
+  storeVerification,
+  updateVerification,
+  deleteVerification,
+  getVerification,
+} from '../verification.js';
+
+const baseVerification = {
+  projectId: 'project-1',
+  status: 'pending' as const,
+  score: 50,
+  summary: 'Initial review',
+  details: ['Initial note'],
+  verifiedAt: new Date('2024-01-01T00:00:00Z').toISOString(),
+};
+
+describe('verification bulk helpers', () => {
+  it('updates existing verification entries', () => {
+    const id = 'ver_update_test';
+    storeVerification({ ...baseVerification, id });
+
+    const updated = updateVerification({ id, status: 'passed', score: 90 });
+
+    expect(updated?.status).toBe('passed');
+    expect(updated?.score).toBe(90);
+  });
+
+  it('deletes verification entries', async () => {
+    const id = 'ver_delete_test';
+    storeVerification({ ...baseVerification, id });
+
+    const deleted = deleteVerification(id);
+
+    expect(deleted).toBe(true);
+    await expect(getVerification(id)).resolves.toBeUndefined();
+  });
+});

backend/src/services/verification.ts

@@ -1,6 +1,21 @@
 import OpenAI from 'openai';
 
-const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+let openaiClient: OpenAI | null = null;
+
+const getOpenAIClient = () => {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      'The OPENAI_API_KEY environment variable is missing or empty; provide it to run verification.'
+    );
+  }
+
+  if (!openaiClient) {
+    openaiClient = new OpenAI({ apiKey });
+  }
+
+  return openaiClient;
+};
 
 interface VerificationRequest {
   repositoryUrl: string;
@@ -18,6 +33,14 @@ interface VerificationResult {
   verifiedAt: string;
 }
 
+export type VerificationUpdate = {
+  id: string;
+  status?: 'passed' | 'failed' | 'pending';
+  score?: number;
+  summary?: string;
+  details?: string[];
+};
+
 // In-memory store (replace with DB in production)
 const verifications = new Map<string, VerificationResult>();
 
@@ -27,7 +50,7 @@ export async function verifyWork(request: VerificationRequest): Promise<Verifica
   // TODO: Fetch actual repo contents via GitHub API
   // For now, use AI to generate a verification assessment
 
-  const completion = await openai.chat.completions.create({
+  const completion = await getOpenAIClient().chat.completions.create({
     model: 'gpt-4o-mini',
     messages: [
       {
@@ -55,10 +78,37 @@ export async function verifyWork(request: VerificationRequest): Promise<Verifica
     verifiedAt: new Date().toISOString(),
   };
 
-  verifications.set(id, result);
+  storeVerification(result);
   return result;
 }
 
+export function storeVerification(result: VerificationResult): void {
+  verifications.set(result.id, result);
+}
+
 export async function getVerification(id: string): Promise<VerificationResult | undefined> {
   return verifications.get(id);
 }
+
+export function updateVerification(update: VerificationUpdate): VerificationResult | undefined {
+  const current = verifications.get(update.id);
+  if (!current) {
+    return undefined;
+  }
+
+  const updated: VerificationResult = {
+    ...current,
+    status: update.status ?? current.status,
+    score: update.score ?? current.score,
+    summary: update.summary ?? current.summary,
+    details: update.details ?? current.details,
+    verifiedAt: new Date().toISOString(),
+  };
+
+  verifications.set(update.id, updated);
+  return updated;
+}
+
+export function deleteVerification(id: string): boolean {
+  return verifications.delete(id);
+}