fix: improve member identity resolve and create api (#4117)

Signed-off-by: Yeganathan S <63534555+skwowet@users.noreply.github.com>

Author: skwowet

backend/src/api/public/v1/members/identities/createMemberIdentity.ts

@@ -6,13 +6,15 @@ import { ConflictError, NotFoundError } from '@crowd/common'
 import {
   MemberField,
   findMemberById,
+  findMemberIdentitiesByValue,
   createMemberIdentity as insertMemberIdentity,
   optionsQx,
   touchMemberUpdatedAt,
+  updateMemberIdentity,
 } from '@crowd/data-access-layer'
 import { IMemberIdentity, MemberIdentityType } from '@crowd/types'
 
-import { created } from '@/utils/api'
+import { created, ok } from '@/utils/api'
 import { validateOrThrow } from '@/utils/validation'
 
 const paramsSchema = z.object({
@@ -33,72 +35,103 @@ const bodySchema = z
     path: ['verifiedBy'],
   })
 
+type DbConstraintError = Error & {
+  constraint?: string
+  original?: { constraint?: string }
+  parent?: { constraint?: string }
+}
+
+function throwIdentityConflict(
+  error: DbConstraintError,
+  data: { platform: string; value: string; type: MemberIdentityType },
+): never {
+  const constraint = error.constraint ?? error.original?.constraint ?? error.parent?.constraint
+
+  if (constraint === 'uix_memberIdentities_platform_value_type_verified') {
+    throw new ConflictError('Identity already verified on another member', data)
+  }
+
+  throw error
+}
+
 export async function createMemberIdentity(req: Request, res: Response): Promise<void> {
   const { memberId } = validateOrThrow(paramsSchema, req.params)
   const data = validateOrThrow(bodySchema, req.body)
 
   const qx = optionsQx(req)
-
   const member = await findMemberById(qx, memberId, [MemberField.ID])
   if (!member) {
     throw new NotFoundError('Member not found')
   }
 
+  // The data-sink writes identity values as trimmed lowercase, so normalize here
+  // to keep idempotency checks reliable against existing rows.
+  const normalizedValue = data.value.trim().toLowerCase()
+  const conflictContext = { platform: data.platform, value: normalizedValue, type: data.type }
+
   let result!: IMemberIdentity
+  let alreadyExisted = false
 
   await captureApiChange(
     req,
     memberEditIdentitiesAction(memberId, async (captureOldState, captureNewState) => {
       captureOldState({})
 
       await qx.tx(async (tx) => {
+        const existing = await findMemberIdentitiesByValue(tx, memberId, normalizedValue, {
+          type: data.type,
+        })
+        const exactMatch = existing.find((i) => i.platform === data.platform)
+
         try {
-          result = await insertMemberIdentity(
-            tx,
-            {
-              memberId,
-              platform: data.platform,
-              value: data.value,
-              type: data.type,
-              source: data.source,
-              verified: data.verified,
-              verifiedBy: data.verifiedBy,
-            },
-            true,
-            true,
-          )
-        } catch (error) {
-          const constraint =
-            error.constraint ?? error.original?.constraint ?? error.parent?.constraint
-
-          if (constraint === 'uix_memberIdentities_memberId_platform_value_type') {
-            throw new ConflictError('Identity already exists on this member', {
-              platform: data.platform,
-              value: data.value,
-              type: data.type,
-            })
+          if (exactMatch) {
+            alreadyExisted = true
+            result = exactMatch
+          } else {
+            result = await insertMemberIdentity(
+              tx,
+              {
+                memberId,
+                platform: data.platform,
+                value: normalizedValue,
+                type: data.type,
+                source: data.source,
+                verified: data.verified,
+                verifiedBy: data.verifiedBy,
+              },
+              true,
+              true,
+            )
           }
 
-          if (constraint === 'uix_memberIdentities_platform_value_type_verified') {
-            throw new ConflictError('Identity already verified on another member', {
-              platform: data.platform,
-              value: data.value,
-              type: data.type,
-            })
+          // A verified identity confirms the same value for this member, so keep same-value
+          // identities in sync instead of leaving stale unverified duplicates behind.
+          if (data.verified && existing.length > 0) {
+            const updatedResults: IMemberIdentity[] = []
+            for (const identity of existing) {
+              const updated = await updateMemberIdentity(tx, memberId, identity.id, {
+                verified: true,
+                verifiedBy: data.verifiedBy,
+              })
+              if (updated) updatedResults.push(updated)
+            }
+
+            if (alreadyExisted) {
+              result = updatedResults.find((r) => r.id === exactMatch.id) ?? result
+            }
           }
-
-          throw error
+        } catch (error) {
+          throwIdentityConflict(error as DbConstraintError, conflictContext)
         }
 
-        // touch member updated at to trigger merge suggestion
         await touchMemberUpdatedAt(tx, memberId)
       })
 
       captureNewState(result)
     }),
   )
 
-  created(res, {
+  const response = {
     id: result.id,
     value: result.value,
     platform: result.platform,
@@ -108,5 +141,11 @@ export async function createMemberIdentity(req: Request, res: Response): Promise
     source: result.source ?? null,
     createdAt: result.createdAt,
     updatedAt: result.updatedAt,
-  })
+  }
+
+  if (alreadyExisted) {
+    ok(res, response)
+  } else {
+    created(res, response)
+  }
 }

backend/src/api/public/v1/members/resolveMember.ts

@@ -23,8 +23,13 @@ export async function resolveMemberByIdentities(req: Request, res: Response): Pr
       platform: PlatformType.LFID,
       type: MemberIdentityType.USERNAME,
       value: lfid,
+      verified: true,
     })),
-    ...(emails?.map((email) => ({ type: MemberIdentityType.EMAIL, value: email })) ?? []),
+    ...(emails?.map((email) => ({
+      type: MemberIdentityType.EMAIL,
+      value: email,
+      verified: true,
+    })) ?? []),
   ]
 
   const memberIds = await findMemberIdsByIdentities(qx, identities)

services/libs/data-access-layer/src/members/identities.ts

@@ -102,7 +102,7 @@ export async function findMemberIdentitiesByValue(
 ): Promise<IMemberIdentity[]> {
   return qx.select(
     `
-        SELECT id, platform, "sourceId", type, value, verified
+        SELECT *
         FROM "memberIdentities"
         WHERE value = $(value) 
           AND "memberId" = $(memberId)