fix: regression on registry participants array

Author: coodos

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

@@ -665,13 +665,28 @@ export class DbService {
                 // field on the meta-envelope (e.g. wiping participantIds when
                 // a read-receipt update arrives).
 
+                // Build the full post-write state by merging the pre-write
+                // envelope set with everything we just wrote. Used by
+                // resolvers to fan out webhooks containing the complete
+                // merged state — receivers overwrite their local row with
+                // whatever the webhook carries, so a partial diff would
+                // make them lose every untouched field.
+                const mergedPayload: Record<string, any> = {};
+                for (const env of workingEnvelopes) {
+                    mergedPayload[env.ontology] = env.value;
+                }
+                for (const env of createdEnvelopes) {
+                    mergedPayload[env.ontology] = env.value;
+                }
+
                 return {
                     metaEnvelope: {
                         id,
                         ontology: meta.ontology,
                         acl,
                     },
                     envelopes: createdEnvelopes,
+                    mergedPayload,
                 };
             });
         } catch (error) {

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

@@ -37,6 +37,11 @@ export type MetaEnvelopeResult<
 
 /**
  * Result type for storing a new meta-envelope.
+ *
+ * `envelopes` are the envelopes touched by this operation. `mergedPayload`,
+ * when present, is the FULL post-write state of the meta-envelope (every
+ * field, not just the touched ones) — used by callers that need to fan out
+ * a webhook with the complete merged state rather than the partial diff.
  */
 export type StoreMetaEnvelopeResult<
     T extends Record<string, any> = Record<string, any>
@@ -47,6 +52,7 @@ export type StoreMetaEnvelopeResult<
         acl: string[];
     };
     envelopes: Envelope<T[keyof T]>[];
+    mergedPayload?: Record<string, any>;
 };
 
 /**

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

@@ -530,14 +530,21 @@ export class GraphQLServer {
                                 parsed: parsedFromEnvelopes,
                             };
 
-                            // Deliver webhooks for update operation
+                            // Deliver webhooks for update operation.
+                            // Use the FULL post-write state, not input.payload —
+                            // input.payload is the partial diff the caller sent,
+                            // and receivers overwrite their local row with
+                            // whatever the webhook carries. Sending the diff
+                            // would make the receiver lose every untouched
+                            // field (e.g. a read-receipt update would wipe
+                            // participantIds on the receiver side).
                             const requestingPlatform =
                                 context.tokenPayload?.platform || null;
                             const webhookPayload = {
                                 id,
                                 w3id: context.eName,
                                 evaultPublicKey: this.evaultPublicKey,
-                                data: input.payload,
+                                data: result.mergedPayload ?? input.payload,
                                 schemaId: input.ontology,
                             };
 
@@ -1222,14 +1229,18 @@ export class GraphQLServer {
                                 context.eName,
                             );
 
-                            // Deliver webhooks for update operation
+                            // Deliver webhooks with the FULL post-write state.
+                            // See the long comment on the new updateMetaEnvelope
+                            // resolver above — sending input.payload (the
+                            // partial diff) would make receivers clobber their
+                            // own untouched fields.
                             const requestingPlatform =
                                 context.tokenPayload?.platform || null;
                             const webhookPayload = {
                                 id: id,
                                 w3id: context.eName,
                                 evaultPublicKey: this.evaultPublicKey,
-                                data: input.payload,
+                                data: result.mergedPayload ?? input.payload,
                                 schemaId: input.ontology,
                             };