Feat/ereputation adapter

platforms/eReputation-api/README.md

@@ -0,0 +1,97 @@
+# eReputation API
+
+This is the API server for the eReputation platform, implementing authentication and web3 integration similar to the dreamSync platform.
+
+## Features
+
+-   **Authentication**: JWT-based authentication with eVault integration
+-   **User Management**: User profiles, search, and updates
+-   **Group Management**: Group creation and management
+-   **Web3 Integration**: Web3 adapter for blockchain integration
+-   **Webhook Support**: Handles webhooks from eVault for user and group updates
+
+## Setup
+
+1. Install dependencies:
+
+```bash
+npm install
+```
+
+2. Set up environment variables in `.env` (in project root):
+
+```env
+# Database
+EREPUTATION_DATABASE_URL=postgresql://username:password@localhost:5432/ereputation
+
+# JWT
+JWT_SECRET=your-secret-key
+
+# Web3 Adapter
+EREPUTATION_MAPPING_DB_PATH=./ereputation-mapping.db
+PUBLIC_REGISTRY_URL=http://localhost:3000
+VITE_EREPUTATION_BASE_URL=http://localhost:8765
+
+# Optional: ANCHR forwarding
+ANCHR_URL=http://localhost:3001
+
+# Optional: Server port
+PORT=8765
+NODE_ENV=development
+```
+
+3. Run the development server:
+
+```bash
+npm run dev
+```
+
+## API Endpoints
+
+### Authentication
+
+-   `GET /api/auth/offer` - Get authentication offer
+-   `POST /api/auth` - Login with eVault credentials
+-   `GET /api/auth/sessions/:id` - SSE stream for auth sessions
+
+### Users
+
+-   `GET /api/users/me` - Get current user profile
+-   `GET /api/users/search?q=query` - Search users
+-   `GET /api/users/:id` - Get user profile by ID
+-   `PATCH /api/users` - Update current user profile
+
+### Webhooks
+
+-   `POST /api/webhook` - Handle eVault webhooks
+
+### Health
+
+-   `GET /api/health` - Health check endpoint
+
+## Architecture
+
+The API follows the same patterns as dreamSync:
+
+1. **Entities**: User and Group models with TypeORM
+2. **Services**: Business logic for users and groups
+3. **Controllers**: HTTP request handlers
+4. **Middleware**: Authentication and authorization
+5. **Web3 Adapter**: Integration with blockchain/web3 systems
+6. **Webhooks**: Handle external updates from eVault
+
+## Database
+
+Uses PostgreSQL with TypeORM for data persistence. The database schema includes:
+
+-   `users` table with profile information
+-   `groups` table for group management
+-   Junction tables for relationships (followers, group members, etc.)
+
+## Web3 Integration
+
+Integrates with the web3-adapter infrastructure to:
+
+-   Sync user data with eVault
+-   Handle group updates
+-   Process webhook events from the blockchain

platforms/eReputation-api/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "ereputation-api",
+    "version": "1.0.0",
+    "description": "eReputation Platform API",
+    "main": "src/index.ts",
+    "scripts": {
+        "start": "ts-node --project tsconfig.json src/index.ts",
+        "dev": "nodemon --exec \"npx ts-node\" src/index.ts",
+        "build": "tsc",
+        "typeorm": "typeorm-ts-node-commonjs",
+        "migration:generate": "typeorm-ts-node-commonjs migration:generate -d src/database/data-source.ts",
+        "migration:run": "typeorm-ts-node-commonjs migration:run -d src/database/data-source.ts",
+        "migration:revert": "typeorm-ts-node-commonjs migration:revert -d src/database/data-source.ts"
+    },
+    "dependencies": {
+        "axios": "^1.6.7",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.5",
+        "express": "^4.18.2",
+        "jsonwebtoken": "^9.0.2",
+        "openai": "^4.20.1",
+        "pg": "^8.11.3",
+        "reflect-metadata": "^0.2.1",
+        "typeorm": "^0.3.24",
+        "uuid": "^9.0.1",
+        "web3-adapter": "link:../../infrastructure/web3-adapter"
+    },
+    "devDependencies": {
+        "@types/cors": "^2.8.17",
+        "@types/express": "^4.17.21",
+        "@types/jsonwebtoken": "^9.0.5",
+        "@types/node": "^20.11.24",
+        "@types/pg": "^8.11.2",
+        "@types/uuid": "^9.0.8",
+        "@typescript-eslint/eslint-plugin": "^7.0.1",
+        "@typescript-eslint/parser": "^7.0.1",
+        "eslint": "^8.56.0",
+        "nodemon": "^3.0.3",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.3.3"
+    }
+}

platforms/eReputation-api/src/controllers/AuthController.ts

@@ -0,0 +1,105 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+import { UserService } from "../services/UserService";
+import { EventEmitter } from "events";
+import { signToken } from "../utils/jwt";
+
+export class AuthController {
+    private userService: UserService;
+    private eventEmitter: EventEmitter;
+
+    constructor() {
+        this.userService = new UserService();
+        this.eventEmitter = new EventEmitter();
+    }
+
+    sseStream = async (req: Request, res: Response) => {
+        const { id } = req.params;
+
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+        });
+
+        const handler = (data: any) => {
+            res.write(`data: ${JSON.stringify(data)}\n\n`);
+        };
+
+        this.eventEmitter.on(id, handler);
+
+        req.on("close", () => {
+            this.eventEmitter.off(id, handler);
+            res.end();
+        });
+
+        req.on("error", (error) => {
+            console.error("SSE Error:", error);
+            this.eventEmitter.off(id, handler);
+            res.end();
+        });
+    };
+
+    getOffer = async (req: Request, res: Response) => {
+        const baseUrl = process.env.VITE_EREPUTATION_BASE_URL || "http://localhost:8765";
+        const url = new URL(
+            "/api/auth",
+            baseUrl,
+        ).toString();
+        const sessionId = uuidv4();
+        const offer = `w3ds://auth?redirect=${url}&session=${sessionId}&platform=ereputation`;
+        res.json({ offer, sessionId });
+    };
+
+    login = async (req: Request, res: Response) => {
+        try {
+            const { ename, session, w3id, signature } = req.body;
+
+            if (!ename) {
+                return res.status(400).json({ error: "ename is required" });
+            }
+
+            if (!session) {
+                return res.status(400).json({ error: "session is required" });
+            }
+
+            // Only find existing users - don't create new ones during auth
+            const user = await this.userService.findUser(ename);
+
+            if (!user) {
+                // User doesn't exist - they need to be created via webhook first
+                return res.status(404).json({ 
+                    error: "User not found", 
+                    message: "User must be created via eVault webhook before authentication" 
+                });
+            }
+
+            const token = signToken({ userId: user.id });
+
+            const data = {
+                user: {
+                    id: user.id,
+                    ename: user.ename,
+                    name: user.name,
+                    handle: user.handle,
+                    description: user.description,
+                    avatarUrl: user.avatarUrl,
+                    bannerUrl: user.bannerUrl,
+                    isVerified: user.isVerified,
+                    isPrivate: user.isPrivate,
+                    email: user.email,
+                    emailVerified: user.emailVerified,
+                    createdAt: user.createdAt,
+                    updatedAt: user.updatedAt,
+                },
+                token,
+            };
+            this.eventEmitter.emit(session, data);
+            res.status(200).send();
+        } catch (error) {
+            console.error("Error during login:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}

platforms/eReputation-api/src/controllers/CalculationController.ts

@@ -0,0 +1,107 @@
+import { Request, Response } from "express";
+import { CalculationService } from "../services/CalculationService";
+import { authGuard } from "../middleware/auth";
+
+export class CalculationController {
+    private calculationService: CalculationService;
+
+    constructor() {
+        this.calculationService = new CalculationService();
+    }
+
+    calculateReputation = async (req: Request, res: Response) => {
+        try {
+            const { targetType, targetId, targetName, userValues } = req.body;
+            const calculatorId = req.user!.id;
+
+            if (!targetType || !targetId || !targetName || !userValues) {
+                return res.status(400).json({ error: "Missing required fields" });
+            }
+
+            // Create calculation record
+            const calculation = await this.calculationService.createCalculation({
+                targetType,
+                targetId,
+                targetName,
+                userValues,
+                calculatorId
+            });
+
+            // Calculate reputation synchronously
+            const result = await this.calculationService.calculateReputation(calculation.id);
+
+            const details = result.calculationDetails ? JSON.parse(result.calculationDetails) : {};
+
+            res.json({
+                score: result.calculatedScore?.toString() || "0",
+                analysis: details.explanation || "No analysis available",
+                targetName: result.targetName,
+                calculationId: result.id
+            });
+        } catch (error) {
+            console.error("Error calculating reputation:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getCalculationResult = async (req: Request, res: Response) => {
+        try {
+            const { calculationId } = req.params;
+            const userId = req.user!.id;
+
+            const calculation = await this.calculationService.getCalculationById(calculationId);
+
+            if (!calculation) {
+                return res.status(404).json({ error: "Calculation not found" });
+            }
+
+            // Check if user is authorized to view this calculation
+            if (calculation.calculatorId !== userId) {
+                return res.status(403).json({ error: "Not authorized to view this calculation" });
+            }
+
+            const details = calculation.calculationDetails ? JSON.parse(calculation.calculationDetails) : {};
+
+            res.json({
+                id: calculation.id,
+                targetType: calculation.targetType,
+                targetName: calculation.targetName,
+                userValues: calculation.userValues,
+                calculatedScore: calculation.calculatedScore,
+                status: calculation.status,
+                details: details,
+                createdAt: calculation.createdAt,
+                updatedAt: calculation.updatedAt
+            });
+        } catch (error) {
+            console.error("Error getting calculation result:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getUserCalculations = async (req: Request, res: Response) => {
+        try {
+            const userId = req.user!.id;
+            const calculations = await this.calculationService.getUserCalculations(userId);
+
+            res.json({
+                calculations: calculations.map(calc => {
+                    const details = calc.calculationDetails ? JSON.parse(calc.calculationDetails) : {};
+                    return {
+                        id: calc.id,
+                        targetType: calc.targetType,
+                        targetName: calc.targetName,
+                        calculatedScore: calc.calculatedScore,
+                        status: calc.status,
+                        details: details,
+                        createdAt: calc.createdAt,
+                        updatedAt: calc.updatedAt
+                    };
+                })
+            });
+        } catch (error) {
+            console.error("Error getting user calculations:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}