createMemberWorkExperience.ts

import type { Request, Response } from 'express'
import { z } from 'zod'

import { captureApiChange, memberEditOrganizationsAction } from '@crowd/audit-logs'
import {
  BadRequestError,
  ConflictError,
  NotFoundError,
  sanitizeMemberOrganizationDateRange,
} from '@crowd/common'
import { signalMemberUpdate } from '@crowd/common_services'
import {
  MemberField,
  changeMemberOrganizationAffiliationOverrides,
  cleanSoftDeletedMemberOrganization,
  createMemberOrganization,
  fetchManyMemberOrgsWithOrgData,
  fetchManyOrganizationAffiliationPolicies,
  findMemberById,
  optionsQx,
} from '@crowd/data-access-layer'
import type {
  IMemberOrganization,
  IMemberRoleWithOrganization,
  MemberOrganizationDateRange,
} from '@crowd/types'

import { created } from '@/utils/api'
import { toMemberWorkExperience } from '@/utils/mapper'
import { validateOrThrow } from '@/utils/validation'

const paramsSchema = z.object({
  memberId: z.uuid(),
})

const bodySchema = z.object({
  organizationId: z.uuid(),
  jobTitle: z.string(),
  verified: z.boolean(),
  verifiedBy: z.string(),
  source: z.string(),
  startDate: z.coerce.date(),
  endDate: z.coerce.date().nullable().optional(),
})

export async function createMemberWorkExperience(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')
  }

  let createdMo: IMemberRoleWithOrganization | undefined

  await captureApiChange(
    req,
    memberEditOrganizationsAction(memberId, async (captureOldState, captureNewState) => {
      captureOldState({})

      let dates: MemberOrganizationDateRange

      try {
        dates = sanitizeMemberOrganizationDateRange(data.startDate, data.endDate, true)
      } catch (error) {
        throw new BadRequestError('Invalid work experience date range')
      }

      const memberOrgData: IMemberOrganization = {
        memberId,
        organizationId: data.organizationId,
        title: data.jobTitle,
        dateStart: dates.dateStart,
        dateEnd: dates.dateEnd,
        source: data.source,
        verified: data.verified,
        verifiedBy: data.verifiedBy,
      }

      let newMemberOrgId: string | undefined

      await qx.tx(async (tx) => {
        await cleanSoftDeletedMemberOrganization(tx, memberId, data.organizationId, memberOrgData)

        newMemberOrgId = await createMemberOrganization(tx, memberId, memberOrgData)

        if (!newMemberOrgId) {
          throw new ConflictError('A work experience with the same dates already exists')
        }

        const orgAffiliationPolicyById = await fetchManyOrganizationAffiliationPolicies(tx, [
          data.organizationId,
        ])

        if (newMemberOrgId && orgAffiliationPolicyById.get(data.organizationId)) {
          await changeMemberOrganizationAffiliationOverrides(tx, [
            {
              memberId,
              memberOrganizationId: newMemberOrgId,
              allowAffiliation: false,
            },
          ])
        }
      })

      // Signal after commit so the workflow sees persisted changes
      await signalMemberUpdate(req.temporal, memberId, {
        memberOrganizationIds: [data.organizationId],
      })

      const orgsMap = await fetchManyMemberOrgsWithOrgData(qx, [memberId])
      createdMo = (orgsMap.get(memberId) ?? []).find((mo) => mo.id === newMemberOrgId)

      captureNewState(createdMo ?? null)
    }),
  )

  if (!createdMo) {
    throw new NotFoundError('Work experience not found after creation')
  }

  created(res, toMemberWorkExperience(createdMo))
}