Feat/ereputation adapter

infrastructure/blindvote/package.json

@@ -21,6 +21,7 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/eventsource": "^1.1.15",
     "@types/jest": "^29.0.0",
     "@types/node": "^20.0.0",
     "jest": "^29.0.0",

infrastructure/eid-wallet/src/lib/ui/Drawer/Drawer.svelte

@@ -2,7 +2,8 @@
 import { cn } from "$lib/utils";
 import { CupertinoPane } from "cupertino-pane";
 import type { Snippet } from "svelte";
-import { swipe } from "svelte-gestures";
+import { useSwipe } from "svelte-gestures";
+import type { SwipeCustomEvent } from "svelte-gestures";
 import type { HTMLAttributes } from "svelte/elements";
 
 interface IDrawerProps extends HTMLAttributes<HTMLDivElement> {
@@ -23,6 +24,24 @@ let {
     ...restProps
 }: IDrawerProps = $props();
 
+const handleDrawerSwipe = (event: SwipeCustomEvent) => {
+    if (event.detail.direction === ("down" as string)) {
+        handleSwipe?.(isPaneOpen);
+    }
+};
+
+const swipeResult = useSwipe(
+    handleDrawerSwipe,
+    () => ({
+        timeframe: 300,
+        minSwipeDistance: 60,
+    }),
+    undefined,
+    true,
+);
+// biome-ignore lint/suspicious/noExplicitAny: svelte-gestures type definitions are incomplete
+const swipe = swipeResult.swipe as any;
+
 // Disabled click outside behavior to prevent white screen issues
 // const handleClickOutside = () => {
 //     pane?.destroy({ animate: true });
@@ -64,11 +83,7 @@ $effect(() => {
 
 <div
     {...restProps}
-    use:swipe={() => ({
-        timeframe: 300,
-        minSwipeDistance: 60,
-    })}
-    onswipe={() => handleSwipe?.(isPaneOpen)}
+    use:swipe
     bind:this={drawerElem}
     class={cn(restProps.class)}
 >

infrastructure/w3id/package.json

@@ -27,6 +27,7 @@
     "devDependencies": {
         "@biomejs/biome": "^1.9.4",
         "@ngneat/falso": "^7.3.0",
+        "@types/eventsource": "^1.1.15",
         "@types/node": "^22.13.10",
         "typescript": "^5.8.2",
         "vitest": "^3.0.9"

platforms/dreamSync/package.json

@@ -98,13 +98,5 @@
     },
     "optionalDependencies": {
         "bufferutil": "^4.0.8"
-    },
-    "pnpm": {
-    "overrides": {
-        "react": "18.3.1",
-        "react-dom": "18.3.1",
-        "@types/react": "18.3.11",
-        "@types/react-dom": "18.3.1"
-        }
     }
 }

platforms/eReputation-api/package.json

@@ -0,0 +1,44 @@
+{
+    "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",
+        "bullmq": "^5.3.0",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.5",
+        "express": "^4.18.2",
+        "ioredis": "^5.3.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,126 @@
+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;
+
+            // Handle self-evaluation: use calculator's ID and name
+            let finalTargetId = targetId;
+            let finalTargetName = targetName;
+            let finalTargetType = targetType;
+
+            if (targetType === "self") {
+                finalTargetId = calculatorId;
+                finalTargetName = req.user!.ename || req.user!.name || "Personal Profile";
+                finalTargetType = "self";
+            }
+
+            if (!finalTargetType || !finalTargetId || !finalTargetName || !userValues) {
+                return res.status(400).json({ error: "Missing required fields" });
+            }
+
+            // Create calculation record
+            const calculation = await this.calculationService.createCalculation({
+                targetType: finalTargetType,
+                targetId: finalTargetId,
+                targetName: finalTargetName,
+                userValues,
+                calculatorId
+            });
+
+            try {
+                // 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 (calcError) {
+                // If calculation fails, the service already deleted the record
+                // Just return an error response
+                console.error("Error calculating reputation:", calcError);
+                const errorMessage = calcError instanceof Error ? calcError.message : "Failed to calculate reputation";
+                res.status(500).json({ error: errorMessage });
+            }
+        } 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" });
+        }
+    };
+}