feat: eReputation and Dreamsync wishlist synchronization (#455)

* feat: eReputation and Dreamsync wishlist synchronization

* chore: remove logs

* chore: change eReputation's wishlist preview to render markdown

* feat: add user profile data to header

Author: coodos

platforms/dreamsync-api/src/web3adapter/mappings/wishlist.mapping.json

@@ -0,0 +1,16 @@
+{
+    "tableName": "wishlists",
+    "schemaId": "770e8400-e29b-41d4-a716-446655440000",
+    "ownerEnamePath": "users(user.ename)",
+    "ownedJunctionTables": [],
+    "localToUniversalMap": {
+        "title": "title",
+        "content": "content",
+        "isActive": "isActive",
+        "isPublic": "isPublic",
+        "metadata": "metadata",
+        "user": "users(user.id),userId",
+        "createdAt": "createdAt",
+        "updatedAt": "updatedAt"
+    }
+}

platforms/dreamsync-api/src/web3adapter/watchers/subscriber.ts

@@ -73,6 +73,28 @@ export class PostgresSubscriber implements EntitySubscriberInterface {
                 }
             }
 
+            // Special handling for Wishlist entities to ensure user relation is loaded
+            if (tableName === "wishlists") {
+                const wishlistRepository = AppDataSource.getRepository("Wishlist");
+                const fullWishlist = await wishlistRepository.findOne({
+                    where: { id: entity.id },
+                    relations: ["user"]
+                });
+                
+                if (fullWishlist && fullWishlist.user) {
+                    enrichedEntity.user = fullWishlist.user;
+                } else if (entity.userId) {
+                    // Fallback: load user by userId if relation wasn't loaded
+                    const userRepository = AppDataSource.getRepository("User");
+                    const user = await userRepository.findOne({
+                        where: { id: entity.userId }
+                    });
+                    if (user) {
+                        enrichedEntity.user = user;
+                    }
+                }
+            }
+
             return this.entityToPlain(enrichedEntity);
         } catch (error) {
             console.error("Error loading relations:", error);

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

@@ -1,6 +1,8 @@
 import { Request, Response } from "express";
 import { CalculationService } from "../services/CalculationService";
 import { authGuard } from "../middleware/auth";
+import { AppDataSource } from "../database/data-source";
+import { Wishlist } from "../database/entities/Wishlist";
 
 export class CalculationController {
     private calculationService: CalculationService;
@@ -25,16 +27,36 @@ export class CalculationController {
                 finalTargetType = "self";
             }
 
-            if (!finalTargetType || !finalTargetId || !finalTargetName || !userValues) {
+            if (!finalTargetType || !finalTargetId || !finalTargetName) {
                 return res.status(400).json({ error: "Missing required fields" });
             }
 
+            // If userValues is empty, check if wishlist exists
+            if (!userValues || !userValues.trim()) {
+                const wishlistRepository = AppDataSource.getRepository(Wishlist);
+                const wishlists = await wishlistRepository.find({
+                    where: {
+                        userId: calculatorId,
+                        isActive: true
+                    },
+                    order: { updatedAt: "DESC" },
+                    take: 1
+                });
+
+                if (wishlists.length === 0 || !wishlists[0].content || !wishlists[0].content.trim()) {
+                    return res.status(400).json({ 
+                        error: "Either provide values you care about, or ensure you have an active wishlist in dreamSync" 
+                    });
+                }
+            }
+
             // Create calculation record
+            // If userValues is empty, pass empty string - service will use wishlist
             const calculation = await this.calculationService.createCalculation({
                 targetType: finalTargetType,
                 targetId: finalTargetId,
                 targetName: finalTargetName,
-                userValues,
+                userValues: userValues || "",
                 calculatorId
             });
 

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

@@ -1,5 +1,7 @@
 import { Request, Response } from "express";
 import { UserService } from "../services/UserService";
+import { AppDataSource } from "../database/data-source";
+import { Wishlist } from "../database/entities/Wishlist";
 
 export class UserController {
     private userService: UserService;
@@ -137,4 +139,42 @@ export class UserController {
             res.status(500).json({ error: "Internal server error" });
         }
     };
+
+    getMyWishlist = async (req: Request, res: Response) => {
+        try {
+            if (!req.user) {
+                return res.status(401).json({ error: "Authentication required" });
+            }
+
+            const wishlistRepository = AppDataSource.getRepository(Wishlist);
+            const wishlists = await wishlistRepository.find({
+                where: {
+                    userId: req.user.id,
+                    isActive: true
+                },
+                order: { updatedAt: "DESC" },
+                take: 1 // Get the most recent active wishlist
+            });
+
+            if (wishlists.length === 0) {
+                return res.json({ wishlist: null });
+            }
+
+            const wishlist = wishlists[0];
+            res.json({
+                wishlist: {
+                    id: wishlist.id,
+                    title: wishlist.title,
+                    content: wishlist.content,
+                    isActive: wishlist.isActive,
+                    isPublic: wishlist.isPublic,
+                    createdAt: wishlist.createdAt,
+                    updatedAt: wishlist.updatedAt,
+                }
+            });
+        } catch (error) {
+            console.error("Error getting user wishlist:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
 }

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

@@ -10,6 +10,7 @@ import { User } from "../database/entities/User";
 import { Group } from "../database/entities/Group";
 import { Poll } from "../database/entities/Poll";
 import { VoteReputationResult } from "../database/entities/VoteReputationResult";
+import { Wishlist } from "../database/entities/Wishlist";
 import { AppDataSource } from "../database/data-source";
 import axios from "axios";
 
@@ -302,6 +303,72 @@ export class WebhookController {
                         });
                     }
                 }
+            } else if (mapping.tableName === "wishlists") {
+                const wishlistRepository = AppDataSource.getRepository(Wishlist);
+                const userRepository = AppDataSource.getRepository(User);
+                
+                // Get userId from user reference
+                let userId: string | null = null;
+                if (local.data.user) {
+                    if (typeof local.data.user === "string" && local.data.user.includes("(")) {
+                        userId = local.data.user.split("(")[1].split(")")[0];
+                    } else if (typeof local.data.user === "object" && local.data.user !== null && "id" in local.data.user) {
+                        userId = (local.data.user as { id: string }).id;
+                    }
+                } else if (local.data.userId) {
+                    userId = local.data.userId as string;
+                }
+                
+                if (!userId) {
+                    return res.status(400).send();
+                }
+                
+                // Load user relation
+                const user = await userRepository.findOne({ where: { id: userId } });
+                if (!user) {
+                    return res.status(400).send();
+                }
+                
+                if (localId) {
+                    // Update existing wishlist
+                    const wishlist = await wishlistRepository.findOne({
+                        where: { id: localId },
+                        relations: ["user"]
+                    });
+                    
+                    if (wishlist) {
+                        wishlist.title = local.data.title as string;
+                        wishlist.content = local.data.content as string;
+                        wishlist.isActive = local.data.isActive as boolean ?? true;
+                        wishlist.isPublic = local.data.isPublic as boolean ?? false;
+                        wishlist.metadata = local.data.metadata as any;
+                        wishlist.user = user;
+                        wishlist.userId = userId;
+                        
+                        await wishlistRepository.save(wishlist);
+                        finalLocalId = wishlist.id;
+                    }
+                } else {
+                    // Create new wishlist
+                    const wishlist = wishlistRepository.create({
+                        title: local.data.title as string,
+                        content: local.data.content as string,
+                        isActive: local.data.isActive as boolean ?? true,
+                        isPublic: local.data.isPublic as boolean ?? false,
+                        metadata: local.data.metadata as any,
+                        user: user,
+                        userId: userId
+                    });
+                    
+                    const savedWishlist = await wishlistRepository.save(wishlist);
+                    
+                    this.adapter.addToLockedIds(savedWishlist.id);
+                    await this.adapter.mappingDb.storeMapping({
+                        localId: savedWishlist.id,
+                        globalId: req.body.id,
+                    });
+                    finalLocalId = savedWishlist.id;
+                }
             }
 
             res.status(200).send();
@@ -315,11 +382,12 @@ export class WebhookController {
         if (!poll.groupId) return;
 
         const group = await this.groupService.getGroupById(poll.groupId);
-        if (!group || !group.charter) return;
+        if (!group) return;
 
+        const charter = (group.charter && group.charter.trim()) ? group.charter : "";
         const reputationResults = await this.votingReputationService.calculateGroupMemberReputations(
             poll.groupId,
-            group.charter
+            charter
         );
 
         const voteReputationResult = await this.votingReputationService.saveReputationResults(

platforms/eReputation-api/src/database/data-source.ts

@@ -10,6 +10,7 @@ import { Vote } from "./entities/Vote";
 import { Poll } from "./entities/Poll";
 import { VoteReputationResult } from "./entities/VoteReputationResult";
 import { Message } from "./entities/Message";
+import { Wishlist } from "./entities/Wishlist";
 import { PostgresSubscriber } from "../web3adapter/watchers/subscriber";
 
 // Use absolute path for better CLI compatibility
@@ -20,7 +21,7 @@ export const dataSourceOptions: DataSourceOptions = {
     type: "postgres",
     url: process.env.EREPUTATION_DATABASE_URL,
     synchronize: false, // Auto-sync in development
-        entities: [User, Group, Reference, Calculation, Vote, Poll, VoteReputationResult, Message],
+        entities: [User, Group, Reference, Calculation, Vote, Poll, VoteReputationResult, Message, Wishlist],
     migrations: [path.join(__dirname, "migrations", "*.ts")],
     logging: process.env.NODE_ENV === "development",
     subscribers: [PostgresSubscriber],

platforms/eReputation-api/src/database/entities/User.ts

@@ -10,6 +10,7 @@ import {
 } from "typeorm";
 import { Vote } from "./Vote";
 import { Poll } from "./Poll";
+import { Wishlist } from "./Wishlist";
 
 @Entity("users")
 export class User {
@@ -73,4 +74,7 @@ export class User {
 
     @OneToMany(() => Vote, (vote) => vote.user)
     votes!: Vote[];
+
+    @OneToMany(() => Wishlist, (wishlist) => wishlist.user)
+    wishlists!: Wishlist[];
 }

platforms/eReputation-api/src/database/entities/Wishlist.ts

@@ -0,0 +1,50 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    CreateDateColumn,
+    UpdateDateColumn,
+    ManyToOne,
+    JoinColumn,
+} from "typeorm";
+import { User } from "./User";
+
+@Entity("wishlists")
+export class Wishlist {
+    @PrimaryGeneratedColumn("uuid")
+    id!: string;
+
+    @Column({ type: "varchar", length: 255 })
+    title!: string;
+
+    @Column({ type: "text" })
+    content!: string; // Markdown content
+
+    @Column({ type: "boolean", default: true })
+    isActive!: boolean;
+
+    @Column({ type: "boolean", default: false })
+    isPublic!: boolean;
+
+    @Column({ type: "jsonb", nullable: true })
+    metadata?: {
+        tags?: string[];
+        categories?: string[];
+        lastAnalyzed?: Date;
+        analysisVersion?: number;
+    };
+
+    @ManyToOne(() => User, (user) => user.wishlists, { onDelete: "CASCADE" })
+    @JoinColumn({ name: "userId" })
+    user!: User;
+
+    @Column({ type: "uuid" })
+    userId!: string;
+
+    @CreateDateColumn()
+    createdAt!: Date;
+
+    @UpdateDateColumn()
+    updatedAt!: Date;
+}
+

platforms/eReputation-api/src/database/migrations/1763660768132-migration.ts

@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class Migration1763660768132 implements MigrationInterface {
+    name = 'Migration1763660768132'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "wishlists" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "title" character varying(255) NOT NULL, "content" text NOT NULL, "isActive" boolean NOT NULL DEFAULT true, "isPublic" boolean NOT NULL DEFAULT false, "metadata" jsonb, "userId" uuid NOT NULL, "createdAt" TIMESTAMP NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_d0a37f2848c5d268d315325f359" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`ALTER TABLE "wishlists" ADD CONSTRAINT "FK_4f3c30555daa6ab0b70a1db772c" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE NO ACTION`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "wishlists" DROP CONSTRAINT "FK_4f3c30555daa6ab0b70a1db772c"`);
+        await queryRunner.query(`DROP TABLE "wishlists"`);
+    }
+
+}

platforms/eReputation-api/src/index.ts

@@ -91,6 +91,7 @@ app.get("/api/users/me", authGuard, userController.currentUser);
 app.get("/api/users/search", userController.search);
 app.get("/api/users/:id", authGuard, userController.getProfileById);
 app.patch("/api/users", authGuard, userController.updateProfile);
+app.get("/api/users/me/wishlist", authGuard, userController.getMyWishlist);
 
 // Group routes
 app.get("/api/groups/search", groupController.search);