fix: recovery issue with facesearch:

Author: coodos

.env.example

@@ -72,6 +72,11 @@ PUBLIC_APP_STORE_EID_WALLET=""
 PUBLIC_PLAY_STORE_EID_WALLET=""
 NOTIFICATION_SHARED_SECRET=your-notification-secret-key
 
+# Shared secret between eid-wallet frontend and evault-core provisioner
+# Backend reads PROVISIONER_SHARED_SECRET, wallet reads PUBLIC_PROVISIONER_SHARED_SECRET
+PROVISIONER_SHARED_SECRET="your-provisioner-shared-secret"
+PUBLIC_PROVISIONER_SHARED_SECRET="your-provisioner-shared-secret"
+
 PUBLIC_ESIGNER_BASE_URL="http://localhost:3004"
 PUBLIC_FILE_MANAGER_BASE_URL="http://localhost:3005"
 

infrastructure/eid-wallet/src/env.d.ts

@@ -6,4 +6,5 @@ declare module "$env/static/public" {
     export const PUBLIC_REGISTRY_URL: string;
     export const PUBLIC_PROVISIONER_URL: string;
     export const PUBLIC_EID_WALLET_TOKEN: string;
+    export const PUBLIC_PROVISIONER_SHARED_SECRET: string;
 }

infrastructure/eid-wallet/src/lib/global/controllers/evault.ts

@@ -11,26 +11,92 @@ import NotificationService from "../../services/NotificationService";
 import type { KeyService } from "./key";
 import type { UserController } from "./user";
 
-const STORE_META_ENVELOPE = `
-  mutation StoreMetaEnvelope($input: MetaEnvelopeInput!) {
-    storeMetaEnvelope(input: $input) {
+const USER_PROFILE_ONTOLOGY = "550e8400-e29b-41d4-a716-446655440000";
+
+const FIND_USER_PROFILE = `
+  query FindUserProfile($ontologyId: String!) {
+    metaEnvelopes(filter: { ontologyId: $ontologyId }, first: 1) {
+      edges {
+        node {
+          id
+          ontology
+          parsed
+        }
+      }
+    }
+  }
+`;
+
+const CREATE_META_ENVELOPE = `
+  mutation CreateMetaEnvelope($input: MetaEnvelopeInput!) {
+    createMetaEnvelope(input: $input) {
+      metaEnvelope {
+        id
+        ontology
+        parsed
+      }
+      errors {
+        message
+        code
+      }
+    }
+  }
+`;
+
+const UPDATE_META_ENVELOPE = `
+  mutation UpdateMetaEnvelope($id: ID!, $input: MetaEnvelopeInput!) {
+    updateMetaEnvelope(id: $id, input: $input) {
       metaEnvelope {
         id
         ontology
         parsed
       }
+      errors {
+        message
+        code
+      }
     }
   }
 `;
 
-interface MetaEnvelopeResponse {
-    storeMetaEnvelope: {
+interface GraphQLErrorItem {
+    message: string;
+    code?: string;
+}
+
+interface ExistingUserProfileEnvelope {
+    id: string;
+    ontology: string;
+    parsed?: Partial<UserProfile>;
+}
+
+interface FindUserProfileResponse {
+    metaEnvelopes: {
+        edges: Array<{
+            node: ExistingUserProfileEnvelope;
+        }>;
+    };
+}
+
+interface CreateMetaEnvelopeResponse {
+    createMetaEnvelope: {
         metaEnvelope: {
             id: string;
             ontology: string;
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            parsed: any;
-        };
+            parsed: UserProfile;
+        } | null;
+        errors: GraphQLErrorItem[] | null;
+    };
+}
+
+interface UpdateMetaEnvelopeResponse {
+    updateMetaEnvelope: {
+        metaEnvelope: {
+            id: string;
+            ontology: string;
+            parsed: UserProfile;
+        } | null;
+        errors: GraphQLErrorItem[] | null;
     };
 }
 
@@ -158,7 +224,7 @@ export class VaultController {
             const userData = await this.#userController.user;
             const displayName = userData?.name || vault.ename;
 
-            await this.createUserProfileInEVault(
+            await this.upsertUserProfileInEVault(
                 vault.ename,
                 displayName,
                 vault.ename,
@@ -167,7 +233,7 @@ export class VaultController {
             this.profileCreationStatus = "success";
         } catch (error) {
             console.error(
-                "Failed to create UserProfile in eVault (retry):",
+                "Failed to upsert UserProfile in eVault (retry):",
                 error,
             );
             this.profileCreationStatus = "failed";
@@ -278,71 +344,133 @@ export class VaultController {
         return this.#client;
     }
 
-    /**
-     * Create UserProfile in eVault with retry mechanism
-     */
-    private async createUserProfileInEVault(
+    private buildUserProfilePayload(
         ename: string,
         displayName: string,
-        w3id: string,
-        maxRetries = 10,
-    ): Promise<void> {
-        console.log("attempting");
+        now: string,
+        existingProfile?: Partial<UserProfile>,
+    ): UserProfile {
         const username = ename.replace("@", "");
-        const now = new Date().toISOString();
-
-        const userProfile: UserProfile = {
-            username,
+        return {
+            username: existingProfile?.username ?? username,
             displayName,
-            bio: null,
-            avatarUrl: null,
-            bannerUrl: null,
-            ename,
-            isVerified: false,
-            isPrivate: false,
-            createdAt: now,
+            bio: existingProfile?.bio ?? null,
+            avatarUrl: existingProfile?.avatarUrl ?? null,
+            bannerUrl: existingProfile?.bannerUrl ?? null,
+            ename: existingProfile?.ename ?? ename,
+            isVerified: existingProfile?.isVerified ?? false,
+            isPrivate: existingProfile?.isPrivate ?? false,
+            createdAt: existingProfile?.createdAt ?? now,
             updatedAt: now,
-            isArchived: false,
+            isArchived: existingProfile?.isArchived ?? false,
         };
+    }
+
+    private async findExistingUserProfile(
+        client: GraphQLClient,
+    ): Promise<ExistingUserProfileEnvelope | undefined> {
+        const response = await client.request<FindUserProfileResponse>(
+            FIND_USER_PROFILE,
+            {
+                ontologyId: USER_PROFILE_ONTOLOGY,
+            },
+        );
+        return response.metaEnvelopes.edges[0]?.node;
+    }
+
+    private throwIfGraphQLErrors(
+        errors: GraphQLErrorItem[] | null | undefined,
+        operation: "create" | "update",
+    ) {
+        if (!errors?.length) return;
+        const message = errors[0]?.message ?? "Unknown GraphQL error";
+        throw new Error(`[UserProfile ${operation}] ${message}`);
+    }
 
+    /**
+     * Upsert UserProfile in eVault with retry mechanism.
+     * Lookup is performed on each attempt to avoid creating duplicates.
+     */
+    private async upsertUserProfileInEVault(
+        ename: string,
+        displayName: string,
+        w3id: string,
+        maxRetries = 10,
+    ): Promise<void> {
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
+                const now = new Date().toISOString();
                 const client = await this.ensureClient(w3id, ename);
+                const existingProfile = await this.findExistingUserProfile(client);
+                const payload = this.buildUserProfilePayload(
+                    ename,
+                    displayName,
+                    now,
+                    existingProfile?.parsed,
+                );
+
+                if (existingProfile?.id) {
+                    console.log(
+                        `Attempting to update existing UserProfile in eVault (attempt ${attempt}/${maxRetries})`,
+                    );
+                    const response = await client.request<UpdateMetaEnvelopeResponse>(
+                        UPDATE_META_ENVELOPE,
+                        {
+                            id: existingProfile.id,
+                            input: {
+                                ontology: USER_PROFILE_ONTOLOGY,
+                                payload,
+                                acl: ["*"],
+                            },
+                        },
+                    );
+                    this.throwIfGraphQLErrors(
+                        response.updateMetaEnvelope.errors,
+                        "update",
+                    );
+                    console.log(
+                        "UserProfile updated successfully in eVault:",
+                        response.updateMetaEnvelope.metaEnvelope?.id ??
+                            existingProfile.id,
+                    );
+                    return;
+                }
 
                 console.log(
                     `Attempting to create UserProfile in eVault (attempt ${attempt}/${maxRetries})`,
                 );
-
-                const response = await client.request<MetaEnvelopeResponse>(
-                    STORE_META_ENVELOPE,
+                const response = await client.request<CreateMetaEnvelopeResponse>(
+                    CREATE_META_ENVELOPE,
                     {
                         input: {
-                            ontology: "550e8400-e29b-41d4-a716-446655440000",
-                            payload: userProfile,
+                            ontology: USER_PROFILE_ONTOLOGY,
+                            payload,
                             acl: ["*"],
                         },
                     },
                 );
-
+                this.throwIfGraphQLErrors(
+                    response.createMetaEnvelope.errors,
+                    "create",
+                );
                 console.log(
                     "UserProfile created successfully in eVault:",
-                    response.storeMetaEnvelope.metaEnvelope.id,
+                    response.createMetaEnvelope.metaEnvelope?.id ?? "unknown-id",
                 );
                 return;
             } catch (error) {
                 console.error(
-                    `Failed to create UserProfile in eVault (attempt ${attempt}/${maxRetries}):`,
+                    `Failed to upsert UserProfile in eVault (attempt ${attempt}/${maxRetries}):`,
                     error,
                 );
 
                 if (attempt === maxRetries) {
                     console.error(
-                        "Max retries reached, giving up on UserProfile creation",
+                        "Max retries reached, giving up on UserProfile upsert",
                     );
                     throw error;
                 }
 
-                // Wait before retrying (exponential backoff)
                 const delay = Math.min(1000 * 2 ** (attempt - 1), 10000);
                 console.log(`Waiting ${delay}ms before retry...`);
                 await new Promise((resolve) => setTimeout(resolve, delay));
@@ -375,15 +503,15 @@ export class VaultController {
                             if (this.profileCreationStatus === "success")
                                 return;
                             this.profileCreationStatus = "loading";
-                            await this.createUserProfileInEVault(
+                            await this.upsertUserProfileInEVault(
                                 resolvedUser?.ename as string,
                                 displayName as string,
                                 resolvedUser?.ename as string,
                             );
                             this.profileCreationStatus = "success";
                         } catch (error) {
                             console.error(
-                                "Failed to create UserProfile in eVault:",
+                                "Failed to upsert UserProfile in eVault:",
                                 error,
                             );
                             this.profileCreationStatus = "failed";
@@ -407,34 +535,34 @@ export class VaultController {
             // Set loading status
             this.profileCreationStatus = "loading";
 
-            // Get user data for display name and create UserProfile
+            // Get user data for display name and upsert UserProfile
             (async () => {
                 try {
                     const userData = await this.#userController.user;
                     const displayName = userData?.name || vault.ename;
 
-                    await this.createUserProfileInEVault(
+                    await this.upsertUserProfileInEVault(
                         vault.ename,
                         displayName,
                         vault.ename,
                     );
                     this.profileCreationStatus = "success";
                 } catch (error) {
                     console.error(
-                        "Failed to get user data or create UserProfile:",
+                        "Failed to get user data or upsert UserProfile:",
                         error,
                     );
                     // Fallback to using ename as display name
                     try {
-                        await this.createUserProfileInEVault(
+                        await this.upsertUserProfileInEVault(
                             vault.ename,
                             vault.ename,
                             vault.ename,
                         );
                         this.profileCreationStatus = "success";
                     } catch (fallbackError) {
                         console.error(
-                            "Failed to create UserProfile in eVault (fallback):",
+                            "Failed to upsert UserProfile in eVault (fallback):",
                             fallbackError,
                         );
                         this.profileCreationStatus = "failed";