chore: implemented patch HTTP method for member project affiliations (CM-1041)

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

@@ -8,6 +8,7 @@ import { getMemberIdentities } from './identities/getMemberIdentities'
 import { verifyMemberIdentity } from './identities/verifyMemberIdentity'
 import { getMemberMaintainerRoles } from './maintainer-roles/getMemberMaintainerRoles'
 import { getProjectAffiliations } from './project-affiliations/getProjectAffiliations'
+import { patchProjectAffiliation } from './project-affiliations/patchProjectAffiliation'
 import { resolveMemberByIdentities } from './resolveMember'
 import { createMemberWorkExperience } from './work-experiences/createMemberWorkExperience'
 import { deleteMemberWorkExperience } from './work-experiences/deleteMemberWorkExperience'
@@ -44,6 +45,12 @@ export function membersRouter(): Router {
     safeWrap(getProjectAffiliations),
   )
 
+  router.patch(
+    '/:memberId/project-affiliations/:projectId',
+    requireScopes([SCOPES.WRITE_PROJECT_AFFILIATIONS]),
+    safeWrap(patchProjectAffiliation),
+  )
+
   router.post(
     '/:memberId/work-experiences',
     requireScopes([SCOPES.WRITE_WORK_EXPERIENCES]),

backend/src/api/public/v1/members/project-affiliations/patchProjectAffiliation.ts

@@ -0,0 +1,104 @@
+import type { Request, Response } from 'express'
+import { z } from 'zod'
+
+import { captureApiChange, memberEditAffiliationsAction } from '@crowd/audit-logs'
+import { NotFoundError } from '@crowd/common'
+import { CommonMemberService } from '@crowd/common_services'
+import {
+  MemberField,
+  fetchMemberSegmentAffiliationForProject,
+  findMemberById,
+  optionsQx,
+  updateMemberSegmentAffiliation,
+} from '@crowd/data-access-layer'
+
+import { ok } from '@/utils/api'
+import { validateOrThrow } from '@/utils/validation'
+
+const paramsSchema = z.object({
+  memberId: z.uuid(),
+  projectId: z.uuid(),
+})
+
+const bodySchema = z
+  .object({
+    organizationId: z.uuid().optional(),
+    dateStart: z.coerce.date().nullable().optional(),
+    dateEnd: z.coerce.date().nullable().optional(),
+    verified: z.boolean().optional(),
+    verifiedBy: z.string().nullable().optional(),
+  })
+  .refine((data) => Object.keys(data).length > 0, {
+    message: 'At least one field must be provided',
+  })
+  .refine(
+    (data) => {
+      const { dateStart, dateEnd } = data
+      if (dateStart != null && dateEnd != null) {
+        return dateEnd >= dateStart
+      }
+      return true
+    },
+    { message: 'dateEnd must be greater than or equal to dateStart' },
+  )
+
+export async function patchProjectAffiliation(req: Request, res: Response): Promise<void> {
+  const { memberId, projectId } = 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')
+  }
+
+  const existing = await fetchMemberSegmentAffiliationForProject(qx, memberId, projectId)
+
+  if (!existing) {
+    throw new NotFoundError('Project affiliation not found')
+  }
+
+  let updated = existing
+
+  await captureApiChange(
+    req,
+    memberEditAffiliationsAction(memberId, async (captureOldState, captureNewState) => {
+      captureOldState(existing)
+
+      await qx.tx(async (tx) => {
+        await updateMemberSegmentAffiliation(tx, memberId, projectId, {
+          ...(data.organizationId !== undefined && { organizationId: data.organizationId }),
+          ...(data.dateStart !== undefined && { dateStart: data.dateStart?.toISOString() ?? null }),
+          ...(data.dateEnd !== undefined && { dateEnd: data.dateEnd?.toISOString() ?? null }),
+          ...(data.verified !== undefined && { verified: data.verified }),
+          ...(data.verifiedBy !== undefined && { verifiedBy: data.verifiedBy }),
+        })
+
+        const organizationId = data.organizationId ?? existing.organizationId
+        if (organizationId) {
+          const service = new CommonMemberService(tx, req.temporal, req.log)
+          await service.startAffiliationRecalculation(memberId, [organizationId])
+        }
+      })
+
+      updated = await fetchMemberSegmentAffiliationForProject(qx, memberId, projectId)
+      if (!updated) {
+        throw new Error('Failed to re-fetch project affiliation after update')
+      }
+      captureNewState(updated)
+    }),
+  )
+
+  ok(res, {
+    id: updated.id,
+    organizationId: updated.organizationId,
+    organizationName: updated.organizationName,
+    organizationLogo: updated.organizationLogo ?? null,
+    verified: updated.verified,
+    verifiedBy: updated.verifiedBy ?? null,
+    startDate: updated.dateStart ?? null,
+    endDate: updated.dateEnd ?? null,
+  })
+}

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

@@ -11,8 +11,8 @@ export interface IProjectAffiliationSegment {
 export interface ISegmentAffiliationWithOrg {
   id: string
   segmentId: string
-  organizationId: string
-  organizationName: string
+  organizationId: string | null
+  organizationName: string | null
   organizationLogo: string | null
   verified: boolean
   verifiedBy: string | null
@@ -88,6 +88,91 @@ export async function fetchMemberSegmentAffiliationsWithOrg(
   )
 }
 
+/**
+ * Fetch a single segment affiliation for a member + project (segment) combination.
+ */
+export async function fetchMemberSegmentAffiliationForProject(
+  qx: QueryExecutor,
+  memberId: string,
+  segmentId: string,
+): Promise<ISegmentAffiliationWithOrg | null> {
+  const rows = await qx.select(
+    `
+      SELECT
+        msa.id,
+        msa."segmentId",
+        msa."organizationId",
+        o."displayName" AS "organizationName",
+        o.logo AS "organizationLogo",
+        msa.verified,
+        msa."verifiedBy",
+        msa."dateStart",
+        msa."dateEnd"
+      FROM "memberSegmentAffiliations" msa
+      LEFT JOIN organizations o ON msa."organizationId" = o.id
+      WHERE msa."memberId" = $(memberId)
+        AND msa."segmentId" = $(segmentId)
+    `,
+    { memberId, segmentId },
+  )
+  return rows[0] ?? null
+}
+
+export interface ISegmentAffiliationUpdate {
+  organizationId?: string
+  dateStart?: string | null
+  dateEnd?: string | null
+  verified?: boolean
+  verifiedBy?: string | null
+}
+
+/**
+ * Partially update a member's segment affiliation for a given project (segment).
+ * Only fields present in `data` are updated.
+ */
+export async function updateMemberSegmentAffiliation(
+  qx: QueryExecutor,
+  memberId: string,
+  segmentId: string,
+  data: ISegmentAffiliationUpdate,
+): Promise<void> {
+  const sets: string[] = []
+  const params: Record<string, unknown> = { memberId, segmentId }
+
+  if ('organizationId' in data) {
+    sets.push('"organizationId" = $(organizationId)')
+    params.organizationId = data.organizationId
+  }
+  if ('dateStart' in data) {
+    sets.push('"dateStart" = $(dateStart)')
+    params.dateStart = data.dateStart
+  }
+  if ('dateEnd' in data) {
+    sets.push('"dateEnd" = $(dateEnd)')
+    params.dateEnd = data.dateEnd
+  }
+  if ('verified' in data) {
+    sets.push('"verified" = $(verified)')
+    params.verified = data.verified
+  }
+  if ('verifiedBy' in data) {
+    sets.push('"verifiedBy" = $(verifiedBy)')
+    params.verifiedBy = data.verifiedBy
+  }
+
+  if (sets.length === 0) return
+
+  await qx.result(
+    `
+      UPDATE "memberSegmentAffiliations"
+      SET ${sets.join(', ')}
+      WHERE "memberId" = $(memberId)
+        AND "segmentId" = $(segmentId)
+    `,
+    params,
+  )
+}
+
 /**
  * Fetch work experiences for a member with organization details.
  * Used as fallback affiliations when no segment affiliations exist for a project.