feat: charter CRUD

Author: coodos

platforms/blabsy-w3ds-auth-api/src/web3adapter/mappings/chat.mapping.json

@@ -6,6 +6,7 @@
     "localToUniversalMap": {
         "name": "name",
         "type": "type",
+        "admins": "user(admins),admins",
         "participants": "user(participants[]),participantIds",
         "lastMessage": "lastMessageId",
         "createdAt": "__date(__calc(createdAt._seconds * 1000)),createdAt",

platforms/group-charter-manager-api/src/controllers/AuthController.ts

@@ -0,0 +1,82 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+import { UserService } from "../services/UserService";
+import { EventEmitter } from "events";
+
+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;
+
+        // Set headers for SSE
+        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);
+
+        // Handle client disconnect
+        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 url = new URL(
+            "/api/auth",
+            process.env.PUBLIC_GROUP_CHARTER_BASE_URL,
+        ).toString();
+        const session = uuidv4();
+        const offer = `w3ds://auth?redirect=${url}&session=${session}&platform=GroupCharter`;
+        res.json({ uri: offer });
+    };
+
+    login = async (req: Request, res: Response) => {
+        try {
+            const { ename, session } = req.body;
+
+            if (!ename) {
+                return res.status(400).json({ error: "ename is required" });
+            }
+
+            const { user, token } =
+                await this.userService.findOrCreateUser(ename);
+
+            const data = {
+                user: {
+                    id: user.id,
+                    ename: user.ename,
+                    isVerified: user.isVerified,
+                    isPrivate: user.isPrivate,
+                },
+                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/group-charter-manager-api/src/controllers/GroupController.ts

@@ -54,8 +54,26 @@ export class GroupController {
     async updateGroup(req: Request, res: Response) {
         try {
             const { id } = req.params;
-            const groupData = req.body;
+            const userId = (req as any).user?.id;
+            
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+
+            const group = await this.groupService.getGroupById(id);
+            if (!group) {
+                return res.status(404).json({ error: "Group not found" });
+            }
+
+            // Check if user is owner or admin
+            const isOwner = group.owner === userId;
+            const isAdmin = group.admins?.includes(userId);
 
+            if (!isOwner && !isAdmin) {
+                return res.status(403).json({ error: "Access denied" });
+            }
+
+            const groupData = req.body;
             const updatedGroup = await this.groupService.updateGroup(id, groupData);
             if (!updatedGroup) {
                 return res.status(404).json({ error: "Group not found" });
@@ -68,6 +86,40 @@ export class GroupController {
         }
     }
 
+    async updateCharter(req: Request, res: Response) {
+        try {
+            const { id } = req.params;
+            const userId = (req as any).user?.id;
+            
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+
+            const group = await this.groupService.getGroupById(id);
+            if (!group) {
+                return res.status(404).json({ error: "Group not found" });
+            }
+
+            // Check if user is a participant in the group
+            const isParticipant = group.participants?.some(p => p.id === userId);
+            if (!isParticipant) {
+                return res.status(403).json({ error: "Access denied - you must be a participant in this group" });
+            }
+
+            const { charter } = req.body;
+            const updatedGroup = await this.groupService.updateGroup(id, { charter });
+            
+            if (!updatedGroup) {
+                return res.status(404).json({ error: "Group not found" });
+            }
+
+            res.json(updatedGroup);
+        } catch (error) {
+            console.error("Error updating charter:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    }
+
     async deleteGroup(req: Request, res: Response) {
         try {
             const { id } = req.params;

platforms/group-charter-manager-api/src/controllers/WebhookController.ts

@@ -19,34 +19,54 @@ export class WebhookController {
 
     handleWebhook = async (req: Request, res: Response) => {
         try {
-            console.log("here")
+            console.log("Webhook received:", {
+                schemaId: req.body.schemaId,
+                globalId: req.body.id,
+                tableName: req.body.data?.tableName
+            });
+
             if (process.env.ANCHR_URL) {
                 axios.post(
                     new URL("group-charter-manager", process.env.ANCHR_URL).toString(),
                     req.body
                 );
             }
+
             const schemaId = req.body.schemaId;
             const globalId = req.body.id;
             const mapping = Object.values(this.adapter.mapping).find(
                 (m) => m.schemaId === schemaId
             );
-            console.log(mapping, this.adapter.mapping, schemaId)
+
+            console.log("Found mapping:", mapping?.tableName);
+            console.log("Available mappings:", Object.keys(this.adapter.mapping));
+
+            if (!mapping) {
+                console.error("No mapping found for schemaId:", schemaId);
+                throw new Error("No mapping found");
+            }
+
+            // Check if this globalId is already locked (being processed)
+            if (this.adapter.lockedIds.includes(globalId)) {
+                console.log("GlobalId already locked, skipping:", globalId);
+                return res.status(200).send();
+            }
+
             this.adapter.addToLockedIds(globalId);
 
-            if (!mapping) throw new Error();
             const local = await this.adapter.fromGlobal({
                 data: req.body.data,
                 mapping,
             });
 
             let localId = await this.adapter.mappingDb.getLocalId(globalId);
+            console.log("Local ID for globalId", globalId, ":", localId);
 
             if (mapping.tableName === "users") {
                 if (localId) {
                     const user = await this.userService.getUserById(localId);
                     if (!user) throw new Error();
-                    
+
                     for (const key of Object.keys(local.data)) {
                         // @ts-ignore
                         user[key] = local.data[key];
@@ -70,7 +90,7 @@ export class WebhookController {
                         isVerified: req.body.data.isVerified,
                         isPrivate: req.body.data.isPrivate,
                     });
-                    
+
                     await this.adapter.mappingDb.storeMapping({
                         localId: user.id,
                         globalId: req.body.id,
@@ -79,57 +99,74 @@ export class WebhookController {
                     this.adapter.addToLockedIds(globalId);
                 }
             } else if (mapping.tableName === "groups") {
+                console.log("Processing group with data:", local.data);
+
                 let participants: User[] = [];
                 if (
                     local.data.participants &&
                     Array.isArray(local.data.participants)
                 ) {
-                    console.log(local);
+                    console.log("Processing participants:", local.data.participants);
                     const participantPromises = local.data.participants.map(
                         async (ref: string) => {
                             if (ref && typeof ref === "string") {
                                 const userId = ref.split("(")[1].split(")")[0];
+                                console.log("Extracted userId:", userId);
                                 return await this.userService.getUserById(userId);
                             }
                             return null;
                         }
                     );
+
                     participants = (
                         await Promise.all(participantPromises)
                     ).filter((user): user is User => user !== null);
+                    console.log("Found participants:", participants.length);
                 }
 
+                let admins = local?.data?.admins as string[] ?? []
+                admins = admins.map((a) => a.includes("(") ? a.split("(")[1].split(")")[0]: a)
+
                 if (localId) {
+                    console.log("Updating existing group with localId:", localId);
                     const group = await this.groupService.getGroupById(localId);
-                    if (!group) return res.status(500).send();
+                    if (!group) {
+                        console.error("Group not found for localId:", localId);
+                        return res.status(500).send();
+                    }
 
                     group.name = local.data.name as string;
                     group.description = local.data.description as string;
                     group.owner = local.data.owner as string;
-                    group.admins = local.data.admins as string[];
+                    group.admins = admins;
                     group.participants = participants;
 
                     this.adapter.addToLockedIds(localId);
                     await this.groupService.groupRepository.save(group);
+                    console.log("Updated group:", group.id);
                 } else {
+                    console.log("Creating new group");
                     const group = await this.groupService.createGroup({
                         name: local.data.name as string,
                         description: local.data.description as string,
                         owner: local.data.owner as string,
-                        admins: local.data.admins as string[],
+                        admins,
                         participants: participants,
                     });
 
+                    console.log("Created group with ID:", group.id);
+                    console.log(group)
                     this.adapter.addToLockedIds(group.id);
                     await this.adapter.mappingDb.storeMapping({
                         localId: group.id,
                         globalId: req.body.id,
                     });
+                    console.log("Stored mapping for group:", group.id, "->", req.body.id);
                 }
             }
             res.status(200).send();
         } catch (e) {
-            console.error(e);
+            console.error("Webhook error:", e);
             res.status(500).send();
         }
     };

platforms/group-charter-manager-api/src/database/data-source.ts

@@ -13,7 +13,7 @@ export const AppDataSource = new DataSource({
     url: process.env.GROUP_CHARTER_DATABASE_URL,
     synchronize: false,
     logging: process.env.NODE_ENV === "development",
-    entities: [User, Group, ],
+    entities: [User, Group ],
     migrations: ["src/database/migrations/*.ts"],
     subscribers: [PostgresSubscriber],
 }); 

platforms/group-charter-manager-api/src/database/entities/Charter.ts

@@ -0,0 +1,46 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    CreateDateColumn,
+    UpdateDateColumn,
+    ManyToOne,
+    JoinColumn,
+} from "typeorm";
+import { Group } from "./Group";
+import { User } from "./User";
+
+@Entity("charters")
+export class Charter {
+    @PrimaryGeneratedColumn("uuid")
+    id!: string;
+
+    @Column({ nullable: true })
+    name!: string;
+
+    @Column({ type: "text", nullable: true })
+    content!: string; // This will store markdown content
+
+    @Column({ default: false })
+    isActive!: boolean;
+
+    @Column({ nullable: true })
+    groupId!: string;
+
+    @ManyToOne(() => Group, { nullable: true })
+    @JoinColumn({ name: "groupId" })
+    group!: Group;
+
+    @Column({ nullable: true })
+    ownerId!: string;
+
+    @ManyToOne(() => User)
+    @JoinColumn({ name: "ownerId" })
+    owner!: User;
+
+    @CreateDateColumn()
+    createdAt!: Date;
+
+    @UpdateDateColumn()
+    updatedAt!: Date;
+} 

platforms/group-charter-manager-api/src/database/entities/Group.ts

@@ -7,7 +7,6 @@ import {
     ManyToMany,
     JoinTable,
 } from "typeorm";
-import { User } from "./User";
 
 @Entity()
 export class Group {
@@ -26,13 +25,16 @@ export class Group {
     @Column("simple-array", { nullable: true })
     admins!: string[];
 
-    @ManyToMany(() => User)
+    @Column({ type: "text", nullable: true })
+    charter!: string; // Markdown content for the group charter
+
+    @ManyToMany("User")
     @JoinTable({
         name: "group_participants",
         joinColumn: { name: "group_id", referencedColumnName: "id" },
         inverseJoinColumn: { name: "user_id", referencedColumnName: "id" }
     })
-    participants!: User[];
+    participants!: any[];
 
     @CreateDateColumn()
     createdAt!: Date;