fix(auth-emailpass): allow email update in updateProvider method

- Added email field to update method type signature
- Email is now saved to user_metadata when passed to updateProvider
- Password remains optional, both fields can be updated independently
- Added integration tests for email and password update scenarios

Fixes #14921

Author: ashif323

packages/modules/providers/auth-emailpass/integration-tests/__tests__/services.spec.ts

@@ -271,5 +271,81 @@ describe("Email password auth provider", () => {
     expect(authServiceSpies.retrieve).toHaveBeenCalled()
 
     expect(resp.error).toEqual("Invalid email or password")
+  
+    })
+
+  it("returns error if entity_id is not passed to update", async () => {
+    const resp = await emailpassService.update(
+      { entity_id: "" },
+      {} as any
+    )
+
+    expect(resp).toEqual({
+      success: false,
+      error: "Cannot update emailpass provider identity without entity_id",
+    })
+  })
+
+  it("updates password if password is passed", async () => {
+    const authServiceSpies = {
+      update: jest.fn().mockImplementation(() => {
+        return {
+          provider_identities: [
+            {
+              entity_id: "test@admin.com",
+              provider: "emailpass",
+              provider_metadata: {},
+            },
+          ],
+        }
+      }),
+    }
+
+    const resp = await emailpassService.update(
+      { entity_id: "test@admin.com", password: "newpassword" },
+      authServiceSpies as any
+    )
+
+    expect(authServiceSpies.update).toHaveBeenCalledWith(
+      "test@admin.com",
+      expect.objectContaining({
+        provider_metadata: expect.objectContaining({
+          password: expect.any(String),
+        }),
+      })
+    )
+    expect(resp.success).toBe(true)
+  })
+
+  it("updates email if email is passed", async () => {
+    const authServiceSpies = {
+      update: jest.fn().mockImplementation(() => {
+        return {
+          provider_identities: [
+            {
+              entity_id: "test@admin.com",
+              provider: "emailpass",
+              provider_metadata: {},
+            },
+          ],
+        }
+      }),
+    }
+
+    const resp = await emailpassService.update(
+      { entity_id: "test@admin.com", email: "newemail@admin.com" },
+      authServiceSpies as any
+    )
+
+    expect(authServiceSpies.update).toHaveBeenCalledWith(
+      "test@admin.com",
+      expect.objectContaining({
+        user_metadata: expect.objectContaining({
+          email: "newemail@admin.com",
+        }),
+      })
+    )
+    expect(resp.success).toBe(true)
   })
 })
+

packages/modules/providers/auth-emailpass/src/services/emailpass.ts

@@ -46,41 +46,44 @@ export class EmailPassAuthService extends AbstractAuthModuleProvider {
   }
 
   async update(
-    data: { password: string; entity_id: string },
-    authIdentityService: AuthIdentityProviderService
-  ) {
-    const { password, entity_id } = data ?? {}
+  data: { password?: string; email?: string; entity_id: string },
+  authIdentityService: AuthIdentityProviderService
+) {
+  const { password, email, entity_id } = data ?? {}
 
-    if (!entity_id) {
-      return {
-        success: false,
-        error: `Cannot update ${this.provider} provider identity without entity_id`,
-      }
+  if (!entity_id) {
+    return {
+      success: false,
+      error: `Cannot update ${this.provider} provider identity without entity_id`,
     }
+  }
 
-    if (!password || !isString(password)) {
-      return { success: true }
-    }
+  let authIdentity
+  const providerMetadataUpdate: Record<string, unknown> = {}
+  const userMetadataUpdate: Record<string, unknown> = {}
 
-    let authIdentity
+  if (password && isString(password)) {
+    providerMetadataUpdate.password = await this.hashPassword(password)
+  }
 
-    try {
-      const passwordHash = await this.hashPassword(password)
+  if (email && isString(email)) {
+    userMetadataUpdate.email = email
+  }
 
-      authIdentity = await authIdentityService.update(entity_id, {
-        provider_metadata: {
-          password: passwordHash,
-        },
-      })
-    } catch (error) {
-      return { success: false, error: error.message }
-    }
+  try {
+    authIdentity = await authIdentityService.update(entity_id, {
+      provider_metadata: providerMetadataUpdate,
+      user_metadata: userMetadataUpdate,
+    })
+  } catch (error) {
+    return { success: false, error: error.message }
+  }
 
-    return {
-      success: true,
-      authIdentity,
-    }
+  return {
+    success: true,
+    authIdentity,
   }
+}
 
   async authenticate(
     userData: AuthenticationInput,