merge: main

Author: sosweetham

infrastructure/evault-core/src/core/db/db.service.ts

@@ -565,6 +565,36 @@ export class DbService {
                 { id, ontology: meta.ontology, acl, eName },
             );
 
+            // Deduplicate envelopes — if multiple Envelope nodes share the
+            // same ontology (field name), keep the first and delete the rest.
+            // This prevents non-deterministic reads where collect(e) returns
+            // duplicates in undefined order and reduce picks the wrong one.
+            const seen = new Map<string, string>(); // ontology → kept envelope id
+            const dupsToDelete: string[] = [];
+            for (const env of existing.envelopes) {
+                if (seen.has(env.ontology)) {
+                    dupsToDelete.push(env.id);
+                } else {
+                    seen.set(env.ontology, env.id);
+                }
+            }
+            if (dupsToDelete.length > 0) {
+                console.warn(
+                    `[eVault] Cleaning ${dupsToDelete.length} duplicate envelope(s) for MetaEnvelope ${id}`,
+                );
+                for (const dupId of dupsToDelete) {
+                    await this.runQueryInternal(
+                        `MATCH (e:Envelope { id: $envelopeId }) DETACH DELETE e`,
+                        { envelopeId: dupId },
+                    );
+                }
+                // Remove deleted dupes from the existing list so the update
+                // loop below doesn't try to reference them.
+                existing.envelopes = existing.envelopes.filter(
+                    (e) => !dupsToDelete.includes(e.id),
+                );
+            }
+
             const createdEnvelopes: Envelope<T[keyof T]>[] = [];
             let counter = 0;
 
@@ -601,21 +631,18 @@ export class DbService {
                             valueType,
                         });
                     } else {
-                        // Create new envelope
+                        // Create new envelope — use MERGE on the relationship
+                        // + ontology to prevent duplicate Envelopes if two
+                        // concurrent updates race.
                         const envW3id = await new W3IDBuilder().build();
                         const envelopeId = envW3id.id;
 
                         await this.runQueryInternal(
                             `
                             MATCH (m:MetaEnvelope { id: $metaId, eName: $eName })
-                            CREATE (${alias}:Envelope {
-                                id: $${alias}_id,
-                                ontology: $${alias}_ontology,
-                                value: $${alias}_value,
-                                valueType: $${alias}_type
-                            })
-                            WITH m, ${alias}
-                            MERGE (m)-[:LINKS_TO]->(${alias})
+                            MERGE (m)-[:LINKS_TO]->(${alias}:Envelope { ontology: $${alias}_ontology })
+                            ON CREATE SET ${alias}.id = $${alias}_id, ${alias}.value = $${alias}_value, ${alias}.valueType = $${alias}_type
+                            ON MATCH SET ${alias}.value = $${alias}_value, ${alias}.valueType = $${alias}_type
                             `,
                             {
                                 metaId: id,

infrastructure/evault-core/src/core/protocol/graphql-server.ts

@@ -374,12 +374,19 @@ export class GraphQLServer {
                                 context.eName,
                             );
 
-                            // Build the full metaEnvelope response
+                            // Build parsed from actual written envelopes, not input
+                            const parsedFromEnvelopes = result.envelopes.reduce(
+                                (acc: Record<string, any>, env: any) => {
+                                    acc[env.ontology] = env.value;
+                                    return acc;
+                                },
+                                {},
+                            );
                             const metaEnvelope = {
                                 id: result.metaEnvelope.id,
                                 ontology: result.metaEnvelope.ontology,
                                 envelopes: result.envelopes,
-                                parsed: input.payload,
+                                parsed: parsedFromEnvelopes,
                             };
 
                             // Deliver webhooks for create operation
@@ -508,12 +515,19 @@ export class GraphQLServer {
                                 context.eName,
                             );
 
-                            // Build the full metaEnvelope response
+                            // Build parsed from actual written envelopes, not input
+                            const parsedFromEnvelopes = result.envelopes.reduce(
+                                (acc: Record<string, any>, env: any) => {
+                                    acc[env.ontology] = env.value;
+                                    return acc;
+                                },
+                                {},
+                            );
                             const metaEnvelope = {
                                 id: result.metaEnvelope.id,
                                 ontology: result.metaEnvelope.ontology,
                                 envelopes: result.envelopes,
-                                parsed: input.payload,
+                                parsed: parsedFromEnvelopes,
                             };
 
                             // Deliver webhooks for update operation

platforms/blabsy/api/src/controllers/WebhookController.ts

@@ -68,7 +68,7 @@ type Message = {
     isSystemMessage?: boolean; // Flag for system messages
 };
 
-dotenv.config({ path: path.resolve(__dirname, "../../../../.env") });
+dotenv.config({ path: path.resolve(__dirname, "../../../../../.env") });
 
 export const adapter = new Web3Adapter({
     schemasPath: path.resolve(__dirname, "../web3adapter/mappings/"),

platforms/blabsy/api/src/index.ts

@@ -9,7 +9,7 @@ import * as fs from "fs";
 import { Web3Adapter } from "./web3adapter";
 import { WebhookController, adapter } from "./controllers/WebhookController";
 
-config({ path: path.resolve(__dirname, "../../../.env") });
+config({ path: path.resolve(__dirname, "../../../../.env") });
 
 const app = express();
 const port = process.env.PORT || 3000;

platforms/blabsy/api/src/web3adapter/watchers/firestoreWatcher.ts

@@ -9,7 +9,7 @@ import { getFirestore } from "firebase-admin/firestore";
 import path from "path";
 import dotenv from "dotenv";
 import { adapter } from "../../controllers/WebhookController";
-dotenv.config({ path: path.resolve(__dirname, "../../../../../.env") });
+dotenv.config({ path: path.resolve(__dirname, "../../../../../../.env") });
 
 export class FirestoreWatcher {
     private unsubscribe: (() => void) | null = null;

platforms/calendar/client/next.config.ts

@@ -4,7 +4,7 @@ import { readFileSync, existsSync } from "fs";
 
 // Read NEXT_PUBLIC_CALENDAR_API_URL from monorepo root .env so client bundle gets it (Next loads project .env first, so process.env can be wrong)
 function getRootEnv(name: string): string | undefined {
-  const rootEnv = path.resolve(__dirname, "../../.env");
+  const rootEnv = path.resolve(__dirname, "../../../.env");
   if (!existsSync(rootEnv)) return undefined;
   const content = readFileSync(rootEnv, "utf-8");
   const match = new RegExp(`^${name}\\s*=\\s*(.+)$`, "m").exec(content);

platforms/cerberus/client/src/database/data-source.ts

@@ -9,8 +9,9 @@ import path from "path";
 import { UserEVaultMapping } from "./entities/UserEVaultMapping";
 import { VotingObservation } from "./entities/VotingObservation";
 import { CharterSignature } from "./entities/CharterSignature";
+import { Reference } from "./entities/Reference";
 
-config({ path: path.resolve(__dirname, "../../../../.env") });
+config({ path: path.resolve(__dirname, "../../../../../.env") });
 
 export const AppDataSource = new DataSource({
     type: "postgres",
@@ -25,6 +26,7 @@ export const AppDataSource = new DataSource({
         UserEVaultMapping,
         VotingObservation,
         CharterSignature,
+        Reference,
     ],
     migrations: [path.join(__dirname, "migrations", "*.ts")],
     subscribers: [PostgresSubscriber],

platforms/cerberus/client/src/database/entities/Reference.ts

@@ -0,0 +1,45 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn, CreateDateColumn, UpdateDateColumn } from "typeorm";
+import { User } from "./User";
+
+@Entity("references")
+export class Reference {
+    @PrimaryGeneratedColumn("uuid")
+    id!: string;
+
+    @Column()
+    targetType!: string; // "user", "group", "platform"
+
+    @Column()
+    targetId!: string;
+
+    @Column()
+    targetName!: string;
+
+    @Column("text")
+    content!: string;
+
+    @Column()
+    referenceType!: string; // "general", "violation", etc.
+
+    @Column("int", { nullable: true })
+    numericScore?: number; // 1-5 score
+
+    @Column()
+    authorId!: string;
+
+    @ManyToOne(() => User)
+    @JoinColumn({ name: "authorId" })
+    author!: User;
+
+    @Column({ default: "signed" })
+    status!: string; // "signed", "revoked"
+
+    @Column({ default: false })
+    anonymous!: boolean;
+
+    @CreateDateColumn()
+    createdAt!: Date;
+
+    @UpdateDateColumn()
+    updatedAt!: Date;
+}

platforms/cerberus/client/src/index.ts

@@ -138,47 +138,19 @@ app.listen(port, () => {
     console.log(`Cerberus API running on port ${port}`);
 });
 
-// Initialize Cerberus intervals and periodic check-ins for groups with charters
+// Initialize Cerberus intervals for groups with charters
 setTimeout(async () => {
     try {
         console.log("🐕 Starting Cerberus services...");
-        
+
         // Import services after server is running
-        const { CharterMonitoringService } = await import("./services/CharterMonitoringService");
-        const { GroupService } = await import("./services/GroupService");
         const { CerberusIntervalService } = await import("./services/CerberusIntervalService");
-        
-        const charterMonitoringService = new CharterMonitoringService();
-        const groupService = new GroupService();
+
         const intervalService = new CerberusIntervalService();
-        
+
         // Initialize Cerberus intervals for all groups with charters
         await intervalService.initializeIntervals();
-        
-        // Send periodic check-ins every 24 hours (separate from charter-based intervals)
-        setInterval(async () => {
-            try {
-                const groups = await groupService.getAllGroups();
-                const groupsWithCharters = groups.filter(group => group.charter && group.charter.trim() !== '');
-                
-                console.log(`🐕 Sending periodic check-ins to ${groupsWithCharters.length} groups with charters...`);
-                
-                for (const group of groupsWithCharters) {
-                    try {
-                        await charterMonitoringService.sendPeriodicCheckIn(group.id, group.name);
-                        // Add a small delay between messages to avoid overwhelming the system
-                        await new Promise(resolve => setTimeout(resolve, 1000));
-                    } catch (error) {
-                        console.error(`Error sending check-in to group ${group.name}:`, error);
-                    }
-                }
-                
-                console.log("✅ Periodic check-ins completed");
-            } catch (error) {
-                console.error("Error during periodic check-ins:", error);
-            }
-        }, 24 * 60 * 60 * 1000); // 24 hours
-        
+
         console.log("✅ Cerberus services initialized");
 
         // Graceful shutdown cleanup