Given the following Apex rest resource implementation for batch upserting assignments and their schedules:

@RestResource(UrlMapping='/reservations/batch/upsert')
global with sharing class ReservationsBatchUpsertResource {

    @HttpPost
    global static ReservationResults upsertReservations(List<Reservation> reservations) {
        Logger.info('Upserting reservations: ' + reservations);
        try {
            ReservationResults results = ReservationService.upsertReservations(reservations);
            if (results.hasErrors()) {
                RestContext.response.statusCode = 400;
            }

            Logger.info('Upserted reservations: ' + reservations);

            return results;
        } catch (Exception e) {
            Logger.error('Failed to upsert reservations: ' + reservations, e);
            throw e;
        } finally {
            Logger.saveLog();
        }
    }
}

public with sharing class ReservationServiceImpl implements IReservationService {

    public ReservationResults upsertReservations(List<Reservation> reservations) {
        List<ReservationSchedule> schedules = mapToSchedules(reservations);
        ReservationResults results = ReservationResultService.createResults(schedules);
        if (results.hasErrors()) {
            return results;
        }

        schedules = ReservationScheduleService.saveSchedules(schedules);

        fflib_ISObjectUnitOfWork uow = Application.UnitOfWork.newInstance();
        deleteAssignments(reservations, uow);
        createAssignments(schedules, uow);
        uow.commitWork();

        return results;
    }

    private static List<ReservationSchedule> mapToSchedules(List<Reservation> reservations) {
        Map<String, Id> projectCodesToIds = mapProjectCodesToIds(reservations);
        Map<String, Id> personnelNumbersToIds = mapPersonnelNumbersToIds(reservations);
        List<ReservationSchedule> schedules = new List<ReservationSchedule>();
        for (Reservation reservation : reservations) {
            String correlationId = getCorrelationId(reservation);
            if (String.isNotBlank(correlationId)) {
                ReservationSchedule schedule = new ReservationSchedule();
                schedule.resourceId = personnelNumbersToIds.get(reservation.personnelNumber);
                schedule.personnelNumber = reservation.personnelNumber;
                schedule.projectId = projectCodesToIds.get(reservation.projectCode);
                schedule.projectCode = reservation.projectCode;
                schedule.load = reservation.load;
                schedule.hours = reservation.hours;
                schedule.worktype = reservation.worktype;
                schedule.startDate = reservation.startDate;
                schedule.endDate = reservation.endDate;
                schedule.billRate = 0;
                schedule.useResourceDefaultCostRate = true;
                schedule.correlationId = correlationId;
                schedule.sourceSystem = reservation.sourceSystem;
                schedule.sourceId = reservation.sourceId;
                schedules.add(schedule);
            }
        }
        return schedules;
    }

    private static String getCorrelationId(Reservation reservation) {
        if (String.isBlank(reservation.sourceSystem) || String.isBlank(reservation.sourceId)) {
            return null;
        }
        return reservation.sourceSystem + '__' + reservation.sourceId;
    }

    private static Map<String, Id> mapProjectCodesToIds(List<Reservation> reservations) {
        Set<String> projectCodes = new Set<String>();
        for (Reservation reservation : reservations) {
            if (String.isNotBlank(reservation.projectCode)) {
                projectCodes.add(reservation.projectCode);
            }
        }
        return ProjectsService.getProjectCodesToIds(projectCodes);
    }

    private static Map<String, Id> mapPersonnelNumbersToIds(List<Reservation> reservations) {
        Set<String> personnelNumbers = new Set<String>();
        for (Reservation reservation : reservations) {
            if (String.isNotBlank(reservation.personnelNumber)) {
                personnelNumbers.add(reservation.personnelNumber);
            }
        }
        return ContactsService.getPersonnelNumbersToIds(personnelNumbers);
    }

    private static void createAssignments(List<ReservationSchedule> schedules, fflib_ISObjectUnitOfWork uow) {
        InsertSObjectsWork work = new InsertSObjectsWork();
        uow.registerWork(work);
        for (ReservationSchedule schedule : schedules) {
            pse__Assignment__c assignment = mapToAssignment(schedule);
            work.add(assignment);
        }
    }

    private static pse__Assignment__c mapToAssignment(ReservationSchedule schedule) {
        pse__Assignment__c assignment = new pse__Assignment__c();
        assignment.NT_Correlation_ID__c = schedule.correlationId;
        assignment.NT_Worktype__c = schedule.worktype;
        assignment.pse__Project__c = schedule.projectId;
        assignment.pse__Resource__c = schedule.resourceId;
        assignment.pse__Schedule__c = schedule.scheduleId;
        assignment.pse__Bill_Rate__c = schedule.billRate;
        assignment.pse__Use_Resource_Default_Cost_Rate__c = schedule.useResourceDefaultCostRate;
        return assignment;
    }

    private static void deleteAssignments(List<Reservation> reservations, fflib_ISObjectUnitOfWork uow) {
        DeleteSObjectsWork work = new DeleteSObjectsWork();
        uow.registerWork(work);
        Set<String> correlationIds = getCorrelationIds(reservations);
        List<pse__Assignment__c> assignments = AssignmentsSelector.newInstance().selectByCorrelationIdsAsSystem(correlationIds);
        work.addAll(assignments);
    }

    public void deleteReservations(List<Reservation> reservations) {
        Set<String> correlationIds = getCorrelationIds(reservations);
        List<pse__Assignment__c> assignments = AssignmentsSelector.newInstance().selectByCorrelationIdsAsSystem(correlationIds);
        fflib_ISObjectUnitOfWork uow = Application.UnitOfWork.newInstance();
        uow.registerDeleted(assignments);
        uow.commitWork();
    }

    private static Set<String> getCorrelationIds(List<Reservation> reservations) {
        Set<String> correlationIds = new Set<String>();
        for (Reservation reservation : reservations) {
            String correlationId = getCorrelationId(reservation);
            if (String.isNotBlank(correlationId)) {
                correlationIds.add(correlationId);
            }
        }
        return correlationIds;
    }
}

/**
 * Custom work action, to be used if the default fflib_SObjectUnitOfWork#commitWork order causes issues.
 * See https://github.com/apex-enterprise-patterns/fflib-apex-common/issues/129
 */
public with sharing class DeleteSObjectsWork implements fflib_SObjectUnitOfWork.IDoWork {
    private final List<SObject> records = new List<SObject>();

    public void add(SObject record) {
        records.add(record);
    }

    public void addAll(List<SObject> records) {
        this.records.addAll(records);
    }

    public void doWork() {
        Database.delete(records, AccessLevel.SYSTEM_MODE);
    }
}

/**
 * Custom work action, to be used if the default fflib_SObjectUnitOfWork#commitWork order causes issues.
 * See https://github.com/apex-enterprise-patterns/fflib-apex-common/issues/129
 */
public with sharing class InsertSObjectsWork implements fflib_SObjectUnitOfWork.IDoWork {
    private final List<SObject> records = new List<SObject>();

    public void add(SObject record) {
        records.add(record);
    }

    public void addAll(List<SObject> records) {
        this.records.addAll(records);
    }

    public void doWork() {
        Database.insert(records, AccessLevel.SYSTEM_MODE);
    }
}

public with sharing class ReservationScheduleServiceImpl implements IReservationScheduleService {

    public List<ReservationSchedule> saveSchedules(List<ReservationSchedule> schedules) {
        List<ReservationSchedule> hoursSchedules = new List<ReservationSchedule>();
        List<ReservationSchedule> percentSchedules = new List<ReservationSchedule>();
        List<pse.SchedulingStrategyService.AdjustHoursScheduleDetail> hoursScheduleDetails = new List<pse.SchedulingStrategyService.AdjustHoursScheduleDetail>();
        List<pse.SchedulingStrategyService.PercentAllocationScheduleDetail> percentScheduleDetails = new List<pse.SchedulingStrategyService.PercentAllocationScheduleDetail>();
        for (ReservationSchedule schedule : schedules) {
            if (schedule.hours != null) {
                hoursSchedules.add(schedule);
                hoursScheduleDetails.add(mapToHoursScheduleDetail(schedule));
            } else {
                percentSchedules.add(schedule);
                percentScheduleDetails.add(mapToPercentScheduleDetail(schedule));
            }
        }

        List<pse.SchedulingStrategyService.ProposedScheduleDetail> proposedScheduleDetails = new List<pse.SchedulingStrategyService.ProposedScheduleDetail>();
        if (!hoursScheduleDetails.isEmpty()) {
            proposedScheduleDetails.addAll(new pse.SchedulingStrategyService().prepareSchedules(hoursScheduleDetails));
        }
        if (!percentScheduleDetails.isEmpty()) {
            proposedScheduleDetails.addAll(new pse.SchedulingStrategyService().prepareSchedules(percentScheduleDetails));
        }

        List<pse.ScheduleSaveDTO> scheduleList = new List<pse.ScheduleSaveDTO>();
        for (pse.SchedulingStrategyService.ProposedScheduleDetail proposedSchedule : proposedScheduleDetails) {
            scheduleList.add(mapToScheduleSaveDTO(proposedSchedule));
        }

        List<pse.ScheduleSaveDTO.SaveResult> results = pse.ScheduleService.saveScheduleData(scheduleList, true);
        Integer hoursSchedulesSize = hoursSchedules.size();
        for (Integer i = 0; i < results.size(); i++) {
            pse.ScheduleSaveDTO.SaveResult saveResult = results.get(i);
            ReservationSchedule schedule = i < hoursSchedulesSize ? hoursSchedules.get(i) : percentSchedules.get(i - hoursSchedulesSize);
            schedule.scheduleId = saveResult.ScheduleId;
        }

        return schedules;
    }

    private static pse.SchedulingStrategyService.AdjustHoursScheduleDetail mapToHoursScheduleDetail(ReservationSchedule schedule) {
        pse.SchedulingStrategyService.AdjustHoursScheduleDetail scheduleDetail = new pse.SchedulingStrategyService.AdjustHoursScheduleDetail();
        scheduleDetail.startDate = schedule.startDate;
        scheduleDetail.endDate = schedule.endDate;
        scheduleDetail.resourceId = schedule.resourceId;
        // disabling holiday constraints to allow assigning hours based on future work calendars
        scheduleDetail.respectHoliday = false;
        scheduleDetail.scheduledHours = schedule.hours;
        return scheduleDetail;
    }

    private static pse.SchedulingStrategyService.PercentAllocationScheduleDetail mapToPercentScheduleDetail(ReservationSchedule schedule) {
        pse.SchedulingStrategyService.PercentAllocationScheduleDetail scheduleDetail = new pse.SchedulingStrategyService.PercentAllocationScheduleDetail();
        scheduleDetail.startDate = schedule.startDate;
        scheduleDetail.endDate = schedule.endDate;
        scheduleDetail.resourceId = schedule.resourceId;
        scheduleDetail.respectHoliday = true;

        pse.SchedulingStrategyService.PercentAllocationRow percentAllocationRow = new pse.SchedulingStrategyService.PercentAllocationRow();
        percentAllocationRow.startDate = schedule.startDate;
        percentAllocationRow.endDate = schedule.endDate;
        percentAllocationRow.percentAllocated = schedule.load;

        scheduleDetail.percentAllocationRows = new List<pse.SchedulingStrategyService.PercentAllocationRow>{
                percentAllocationRow
        };

        return scheduleDetail;
    }

    private static pse.ScheduleSaveDTO mapToScheduleSaveDTO(pse.SchedulingStrategyService.ProposedScheduleDetail proposedSchedule) {
        pse.ScheduleSaveDTO scheduleSaveDTO = new pse.ScheduleSaveDTO();
        scheduleSaveDTO.StartDate = proposedSchedule.schedule.startDate;
        scheduleSaveDTO.EndDate = proposedSchedule.schedule.endDate;
        scheduleSaveDTO.MondayHours = proposedSchedule.schedule.mondayHours;
        scheduleSaveDTO.TuesdayHours = proposedSchedule.schedule.tuesdayHours;
        scheduleSaveDTO.WednesdayHours = proposedSchedule.schedule.wednesdayHours;
        scheduleSaveDTO.ThursdayHours = proposedSchedule.schedule.thursdayHours;
        scheduleSaveDTO.FridayHours = proposedSchedule.schedule.fridayHours;
        scheduleSaveDTO.SaturdayHours = proposedSchedule.schedule.saturdayHours;
        scheduleSaveDTO.SundayHours = proposedSchedule.schedule.sundayHours;
        scheduleSaveDTO.ExceptionsToInsert = mapToScheduleExceptionDTOList(proposedSchedule.scheduleExceptions);
        return scheduleSaveDTO;
    }

    private static List<pse.ScheduleSaveDTO.ScheduleExceptionDTO> mapToScheduleExceptionDTOList(List<pse.SchedulingStrategyService.SchedulePattern> schedulePatterns) {
        List<pse.ScheduleSaveDTO.ScheduleExceptionDTO> scheduleExceptionDtos = new List<pse.ScheduleSaveDTO.ScheduleExceptionDTO>();
        for (pse.SchedulingStrategyService.SchedulePattern schedulePattern : schedulePatterns) {
            pse.ScheduleSaveDTO.ScheduleExceptionDTO scheduleExceptionDto = new pse.ScheduleSaveDTO.ScheduleExceptionDTO();
            scheduleExceptionDto.StartDate = schedulePattern.startDate;
            scheduleExceptionDto.EndDate = schedulePattern.endDate;
            scheduleExceptionDto.MondayHours = schedulePattern.mondayHours;
            scheduleExceptionDto.TuesdayHours = schedulePattern.tuesdayHours;
            scheduleExceptionDto.WednesdayHours = schedulePattern.wednesdayHours;
            scheduleExceptionDto.ThursdayHours = schedulePattern.thursdayHours;
            scheduleExceptionDto.FridayHours = schedulePattern.fridayHours;
            scheduleExceptionDto.SaturdayHours = schedulePattern.saturdayHours;
            scheduleExceptionDto.SundayHours = schedulePattern.sundayHours;
            scheduleExceptionDto.ExceptionHours = 0;
            scheduleExceptionDtos.add(scheduleExceptionDto);
        }
        return scheduleExceptionDtos;
    }
}

In case the assignment already exists for the correlation id, the previous assignment and schedule are moved to the recycle bin instead of being totally removed.
What changes are needed to remove them at once?