@twentyhq/call-recorder 1.0.1 → 1.0.2

package/src/logic-functions/flows/reconcile-call-recorder.util.ts

@@ -1,495 +0,0 @@
-import { isUndefined } from '@sniptt/guards';
-import { type CoreApiClient } from 'twenty-client-sdk/core';
-
-import { CallRecordingRequestStatus } from 'src/logic-functions/constants/call-recording-request-status';
-import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
-import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';
-import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';
-import { type CallRecorderPolicyResultForMeeting } from 'src/logic-functions/types/call-recorder-policy-result-for-meeting.type';
-import { type CallRecorderReconciliationResult } from 'src/logic-functions/types/call-recorder-reconciliation-result.type';
-import { type RemovedCallRecorderOccurrence } from 'src/logic-functions/types/removed-call-recorder-occurrence.type';
-import { aggregateCallRecorderPolicyResultsByMeeting } from 'src/logic-functions/domain/aggregate-call-recorder-policy-results-by-meeting.util';
-import { buildCallRecorderPolicyResult } from 'src/logic-functions/domain/build-call-recorder-policy-result.util';
-import { cancelCallRecordingRequest } from 'src/logic-functions/flows/cancel-call-recording-request.util';
-import { computeCallRecordingIdForMeeting } from 'src/logic-functions/domain/compute-call-recording-id-for-meeting.util';
-import {
-  createCallRecording,
-  type ScheduledCallRecordingFields,
-} from 'src/logic-functions/data/create-call-recording.util';
-import { ensureCallRecorder } from 'src/logic-functions/flows/ensure-call-recorder.util';
-import { fetchCalendarEventsByIds } from 'src/logic-functions/data/fetch-calendar-events-by-ids.util';
-import { fetchCalendarEventsByStartsAtValues } from 'src/logic-functions/data/fetch-calendar-events-by-starts-at-values.util';
-import { findCallRecordingsByCalendarEventIds } from 'src/logic-functions/data/find-call-recordings-by-calendar-event-ids.util';
-import { findCallRecordingsByIds } from 'src/logic-functions/data/find-call-recordings-by-ids.util';
-import { getUniqueSortedIds } from 'src/logic-functions/utils/get-unique-sorted-ids.util';
-import { rescheduleCallRecordingBot } from 'src/logic-functions/flows/reschedule-call-recording-bot.util';
-import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';
-import { type CallRecordingUpdateFields } from 'src/logic-functions/types/call-recording-update-fields.type';
-
-export const reconcileCallRecorderForCalendarEventIds = async ({
-  client,
-  calendarEventIds,
-  removedOccurrences = [],
-  now = new Date(),
-}: {
-  client: CoreApiClient;
-  calendarEventIds: string[];
-  removedOccurrences?: RemovedCallRecorderOccurrence[];
-  now?: Date;
-}): Promise<CallRecorderReconciliationResult[]> => {
-  const meetingPolicyResults =
-    await resolveCallRecorderPolicyResultsForMeetings({
-      client,
-      calendarEventIds,
-      removedOccurrences,
-      now,
-    });
-
-  return reconcileCallRecorderForMeetingOccurrences({
-    client,
-    meetingPolicyResults,
-    removedOccurrences,
-  });
-};
-
-const resolveCallRecorderPolicyResultsForMeetings = async ({
-  client,
-  calendarEventIds,
-  removedOccurrences = [],
-  now = new Date(),
-}: {
-  client: CoreApiClient;
-  calendarEventIds: string[];
-  removedOccurrences?: RemovedCallRecorderOccurrence[];
-  now?: Date;
-}): Promise<CallRecorderPolicyResultForMeeting[]> => {
-  const changedCalendarEvents = await fetchCalendarEventsByIds(
-    client,
-    getUniqueSortedIds(calendarEventIds),
-  );
-  const affectedMeetingKeys = new Set<string>();
-  const occurrenceStartsAtAnchors = new Set<string>();
-  const changedCalendarEventPolicyResults = changedCalendarEvents.map(
-    (calendarEvent) => buildCallRecorderPolicyResult(calendarEvent, now),
-  );
-
-  for (const policyResult of changedCalendarEventPolicyResults) {
-    affectedMeetingKeys.add(policyResult.realMeetingKey);
-  }
-
-  for (const calendarEvent of changedCalendarEvents) {
-    if (!isUndefined(calendarEvent.startsAt)) {
-      occurrenceStartsAtAnchors.add(calendarEvent.startsAt);
-    }
-  }
-
-  for (const removedOccurrence of removedOccurrences) {
-    affectedMeetingKeys.add(removedOccurrence.realMeetingKey);
-
-    if (!isUndefined(removedOccurrence.startsAt)) {
-      occurrenceStartsAtAnchors.add(removedOccurrence.startsAt);
-    }
-  }
-
-  if (affectedMeetingKeys.size === 0) {
-    return [];
-  }
-
-  const occurrenceSiblingEvents = await fetchCalendarEventsByStartsAtValues(
-    client,
-    [...occurrenceStartsAtAnchors],
-  );
-  const policyResultsByCalendarEventId = new Map(
-    changedCalendarEventPolicyResults.map((policyResult) => [
-      policyResult.calendarEventId,
-      policyResult,
-    ]),
-  );
-
-  for (const calendarEvent of occurrenceSiblingEvents) {
-    if (policyResultsByCalendarEventId.has(calendarEvent.id)) {
-      continue;
-    }
-
-    policyResultsByCalendarEventId.set(
-      calendarEvent.id,
-      buildCallRecorderPolicyResult(calendarEvent, now),
-    );
-  }
-
-  const perCalendarEventPolicyResults = [
-    ...policyResultsByCalendarEventId.values(),
-  ]
-    .filter((policyResult) =>
-      affectedMeetingKeys.has(policyResult.realMeetingKey),
-    )
-    .map((policyResult) => ({
-      calendarEventId: policyResult.calendarEventId,
-      realMeetingKey: policyResult.realMeetingKey,
-      shouldRequestBot: policyResult.shouldRequestBot,
-    }));
-  const meetingPolicyResults = aggregateCallRecorderPolicyResultsByMeeting(
-    perCalendarEventPolicyResults,
-  );
-  const meetingKeysWithPolicyResult = new Set(
-    meetingPolicyResults.map(
-      (meetingPolicyResult) => meetingPolicyResult.realMeetingKey,
-    ),
-  );
-
-  for (const meetingKey of [...affectedMeetingKeys].sort()) {
-    if (meetingKeysWithPolicyResult.has(meetingKey)) {
-      continue;
-    }
-
-    meetingPolicyResults.push({
-      realMeetingKey: meetingKey,
-      shouldRequestBot: false,
-      calendarEventIds: [],
-      requestingCalendarEventIds: [],
-    });
-  }
-
-  return meetingPolicyResults;
-};
-
-const reconcileCallRecorderForMeetingOccurrences = async ({
-  client,
-  meetingPolicyResults,
-  removedOccurrences = [],
-}: {
-  client: CoreApiClient;
-  meetingPolicyResults: CallRecorderPolicyResultForMeeting[];
-  removedOccurrences?: RemovedCallRecorderOccurrence[];
-}): Promise<CallRecorderReconciliationResult[]> => {
-  const removedCalendarEventIdsByMeetingKey =
-    buildRemovedCalendarEventIdsByMeetingKey(removedOccurrences);
-  const reconciliationResults: CallRecorderReconciliationResult[] = [];
-  const orderedMeetingPolicyResults = [
-    ...meetingPolicyResults.filter(
-      (meetingPolicyResult) => !meetingPolicyResult.shouldRequestBot,
-    ),
-    ...meetingPolicyResults.filter(
-      (meetingPolicyResult) => meetingPolicyResult.shouldRequestBot,
-    ),
-  ];
-
-  for (const meetingPolicyResult of orderedMeetingPolicyResults) {
-    const removedCalendarEventIds =
-      removedCalendarEventIdsByMeetingKey.get(
-        meetingPolicyResult.realMeetingKey,
-      ) ?? [];
-
-    try {
-      reconciliationResults.push(
-        meetingPolicyResult.shouldRequestBot
-          ? await reconcileActiveMeeting({
-              client,
-              meetingPolicyResult,
-              removedCalendarEventIds,
-            })
-          : await reconcileCanceledMeeting({
-              client,
-              meetingPolicyResult,
-              removedCalendarEventIds,
-            }),
-      );
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-
-      console.error(
-        `[call-recorder] reconciliation failed for meeting ${meetingPolicyResult.realMeetingKey}: ${errorMessage}`,
-      );
-      reconciliationResults.push({
-        action: 'FAILED',
-        realMeetingKey: meetingPolicyResult.realMeetingKey,
-        errorMessage,
-      });
-    }
-  }
-
-  return reconciliationResults;
-};
-
-const reconcileActiveMeeting = async ({
-  client,
-  meetingPolicyResult,
-  removedCalendarEventIds,
-}: {
-  client: CoreApiClient;
-  meetingPolicyResult: CallRecorderPolicyResultForMeeting;
-  removedCalendarEventIds: string[];
-}): Promise<CallRecorderReconciliationResult> => {
-  const representativeCalendarEventId = getUniqueSortedIds(
-    meetingPolicyResult.requestingCalendarEventIds,
-  )[0];
-
-  if (isUndefined(representativeCalendarEventId)) {
-    return buildSkippedResult(meetingPolicyResult.realMeetingKey);
-  }
-
-  const representativeCalendarEvent = (
-    await fetchCalendarEventsByIds(client, [representativeCalendarEventId])
-  )[0];
-
-  if (isUndefined(representativeCalendarEvent)) {
-    return buildSkippedResult(meetingPolicyResult.realMeetingKey);
-  }
-
-  const callRecordingId = computeCallRecordingIdForMeeting(
-    meetingPolicyResult.realMeetingKey,
-  );
-  const existingCallRecording = (
-    await findCallRecordingsByIds(client, [callRecordingId])
-  )[0];
-
-  if (!isUndefined(existingCallRecording)) {
-    return updatePolicyManagedCallRecording({
-      client,
-      existingCallRecording,
-      representativeCalendarEvent,
-      realMeetingKey: meetingPolicyResult.realMeetingKey,
-    });
-  }
-
-  const manualOpenCallRecording = await findManualOpenCallRecording({
-    client,
-    meetingPolicyResult,
-    removedCalendarEventIds,
-  });
-
-  if (!isUndefined(manualOpenCallRecording)) {
-    return {
-      action: 'SKIPPED',
-      realMeetingKey: meetingPolicyResult.realMeetingKey,
-      callRecordingId: manualOpenCallRecording.id,
-    };
-  }
-
-  return createPolicyManagedCallRecording({
-    client,
-    callRecordingId,
-    representativeCalendarEvent,
-    realMeetingKey: meetingPolicyResult.realMeetingKey,
-  });
-};
-
-const updatePolicyManagedCallRecording = async ({
-  client,
-  existingCallRecording,
-  representativeCalendarEvent,
-  realMeetingKey,
-}: {
-  client: CoreApiClient;
-  existingCallRecording: CallRecordingRecord;
-  representativeCalendarEvent: CalendarEventRecord;
-  realMeetingKey: string;
-}): Promise<CallRecorderReconciliationResult> => {
-  await updateCallRecording(client, {
-    id: existingCallRecording.id,
-    data: buildPolicyManagedCallRecordingUpdateFields({
-      existingCallRecording,
-      calendarEvent: representativeCalendarEvent,
-    }),
-  });
-  await rescheduleCallRecordingBot(client, {
-    callRecording: existingCallRecording,
-    calendarEvent: representativeCalendarEvent,
-  });
-
-  return {
-    action: 'UPDATED',
-    realMeetingKey,
-    callRecordingId: existingCallRecording.id,
-  };
-};
-
-const createPolicyManagedCallRecording = async ({
-  client,
-  callRecordingId,
-  representativeCalendarEvent,
-  realMeetingKey,
-}: {
-  client: CoreApiClient;
-  callRecordingId: string;
-  representativeCalendarEvent: CalendarEventRecord;
-  realMeetingKey: string;
-}): Promise<CallRecorderReconciliationResult> => {
-  const scheduledFields = buildScheduledCallRecordingFields(
-    representativeCalendarEvent,
-  );
-
-  try {
-    await createCallRecording(client, {
-      id: callRecordingId,
-      data: scheduledFields,
-    });
-  } catch (error) {
-    // The id is deterministic, so a conflict means a concurrent run created the row first.
-    const concurrentlyCreatedCallRecording = (
-      await findCallRecordingsByIds(client, [callRecordingId])
-    )[0];
-
-    if (isUndefined(concurrentlyCreatedCallRecording)) {
-      throw error;
-    }
-
-    return updatePolicyManagedCallRecording({
-      client,
-      existingCallRecording: concurrentlyCreatedCallRecording,
-      representativeCalendarEvent,
-      realMeetingKey,
-    });
-  }
-
-  // Winning the deterministic-id insert elects this run as the single writer that creates the bot.
-  await ensureCallRecorder(client, {
-    callRecording: {
-      id: callRecordingId,
-      ...scheduledFields,
-      title: scheduledFields.title ?? undefined,
-    },
-    calendarEvent: representativeCalendarEvent,
-  });
-
-  return {
-    action: 'CREATED',
-    realMeetingKey,
-    callRecordingId,
-  };
-};
-
-const findManualOpenCallRecording = async ({
-  client,
-  meetingPolicyResult,
-  removedCalendarEventIds,
-}: {
-  client: CoreApiClient;
-  meetingPolicyResult: CallRecorderPolicyResultForMeeting;
-  removedCalendarEventIds: string[];
-}): Promise<CallRecordingRecord | undefined> => {
-  const calendarEventIds = getUniqueSortedIds([
-    ...meetingPolicyResult.calendarEventIds,
-    ...meetingPolicyResult.requestingCalendarEventIds,
-    ...removedCalendarEventIds,
-  ]);
-  const callRecordings = await findCallRecordingsByCalendarEventIds(
-    client,
-    calendarEventIds,
-  );
-
-  return [...callRecordings]
-    .sort((firstCallRecording, secondCallRecording) =>
-      firstCallRecording.id.localeCompare(secondCallRecording.id),
-    )
-    .find(
-      (callRecording) =>
-        callRecording.status !== CallRecordingStatus.COMPLETED &&
-        isUndefined(callRecording.recordingRequestStatus),
-    );
-};
-
-const reconcileCanceledMeeting = async ({
-  client,
-  meetingPolicyResult,
-  removedCalendarEventIds,
-}: {
-  client: CoreApiClient;
-  meetingPolicyResult: CallRecorderPolicyResultForMeeting;
-  removedCalendarEventIds: string[];
-}): Promise<CallRecorderReconciliationResult> => {
-  const calendarEventIds = getUniqueSortedIds([
-    ...meetingPolicyResult.calendarEventIds,
-    ...removedCalendarEventIds,
-  ]);
-  const cancellableCallRecordings = (
-    await findCallRecordingsByCalendarEventIds(client, calendarEventIds)
-  ).filter(
-    (callRecording) =>
-      callRecording.status === CallRecordingStatus.SCHEDULED &&
-      callRecording.recordingRequestStatus ===
-        CallRecordingRequestStatus.REQUESTED,
-  );
-
-  if (cancellableCallRecordings.length === 0) {
-    return buildSkippedResult(meetingPolicyResult.realMeetingKey);
-  }
-
-  for (const callRecording of cancellableCallRecordings) {
-    await cancelCallRecordingRequest({
-      client,
-      callRecording,
-    });
-  }
-
-  return {
-    action: 'CANCELED',
-    realMeetingKey: meetingPolicyResult.realMeetingKey,
-    callRecordingId: cancellableCallRecordings[0].id,
-  };
-};
-
-// startedAt/endedAt come from the webhook; calendar writes never touch them.
-const buildCalendarDrivenCallRecordingFields = (
-  calendarEvent: CalendarEventRecord,
-): Omit<ScheduledCallRecordingFields, 'status'> => ({
-  // Wire null clears a stale title when the calendar title is gone or restricted.
-  title: calendarEvent.title ?? null,
-  recordingRequestStatus: CallRecordingRequestStatus.REQUESTED,
-  calendarEventId: calendarEvent.id,
-});
-
-const buildScheduledCallRecordingFields = (
-  calendarEvent: CalendarEventRecord,
-): ScheduledCallRecordingFields => ({
-  ...buildCalendarDrivenCallRecordingFields(calendarEvent),
-  status: CallRecordingStatus.SCHEDULED,
-});
-
-// A live or finished bot lifecycle must never be reset to SCHEDULED by a calendar-driven update.
-const buildPolicyManagedCallRecordingUpdateFields = ({
-  existingCallRecording,
-  calendarEvent,
-}: {
-  existingCallRecording: CallRecordingRecord;
-  calendarEvent: CalendarEventRecord;
-}): CallRecordingUpdateFields =>
-  canResetCallRecordingStatusToScheduled(existingCallRecording.status)
-    ? {
-        ...buildScheduledCallRecordingFields(calendarEvent),
-        ...(isUndefined(existingCallRecording.callRecorderFailureReason)
-          ? {}
-          : { callRecorderFailureReason: null }),
-      }
-    : buildCalendarDrivenCallRecordingFields(calendarEvent);
-
-const canResetCallRecordingStatusToScheduled = (
-  status: string | undefined,
-): boolean =>
-  status === CallRecordingStatus.SCHEDULED ||
-  status === CallRecordingStatus.FAILED;
-
-const buildRemovedCalendarEventIdsByMeetingKey = (
-  removedOccurrences: RemovedCallRecorderOccurrence[],
-): Map<string, string[]> => {
-  const calendarEventIdsByMeetingKey = new Map<string, string[]>();
-
-  for (const removedOccurrence of removedOccurrences) {
-    calendarEventIdsByMeetingKey.set(removedOccurrence.realMeetingKey, [
-      ...(calendarEventIdsByMeetingKey.get(removedOccurrence.realMeetingKey) ??
-        []),
-      removedOccurrence.calendarEventId,
-    ]);
-  }
-
-  return calendarEventIdsByMeetingKey;
-};
-
-const buildSkippedResult = (
-  realMeetingKey: string,
-): CallRecorderReconciliationResult => ({
-  action: 'SKIPPED',
-  realMeetingKey,
-  callRecordingId: null,
-});

package/src/logic-functions/flows/reconcile-call-recording-transcript-artifact-result.type.ts

@@ -1,11 +0,0 @@
-import { type CallRecordingUpdateFields } from 'src/logic-functions/types/call-recording-update-fields.type';
-
-type CallRecordingTranscriptArtifactUpdateFields = Pick<
-  CallRecordingUpdateFields,
-  'callRecorderFailureReason' | 'status' | 'transcript'
->;
-
-export type ReconcileCallRecordingTranscriptArtifactResult = {
-  updateData: CallRecordingTranscriptArtifactUpdateFields;
-  requestedTranscript: boolean;
-};

package/src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util.ts

@@ -1,182 +0,0 @@
-import { isNull, isUndefined } from '@sniptt/guards';
-
-import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
-import { buildFailedTranscriptMarker } from 'src/logic-functions/domain/build-failed-transcript-marker.util';
-import { buildPendingTranscriptMarker } from 'src/logic-functions/domain/build-pending-transcript-marker.util';
-import { buildTranscriptFailureReason } from 'src/logic-functions/domain/build-transcript-failure-reason.util';
-import { isCallRecordingStatusDowngrade } from 'src/logic-functions/domain/is-call-recording-status-downgrade.util';
-import { parseTranscriptMarker } from 'src/logic-functions/domain/parse-transcript-marker.util';
-import { createAsyncRecallTranscript } from 'src/logic-functions/recall-api/create-async-recall-transcript.util';
-import { listRecallTranscripts } from 'src/logic-functions/recall-api/list-recall-transcripts.util';
-import { type RecallTranscriptSummary } from 'src/logic-functions/recall-api/recall-transcript-summary.type';
-import { downloadTranscript } from 'src/logic-functions/flows/download-transcript.util';
-import { type ReconcileCallRecordingTranscriptArtifactResult } from 'src/logic-functions/flows/reconcile-call-recording-transcript-artifact-result.type';
-
-type CallRecordingTranscriptArtifactUpdateFields =
-  ReconcileCallRecordingTranscriptArtifactResult['updateData'];
-
-export const reconcileCallRecordingTranscriptArtifact = async ({
-  callRecordingId,
-  currentStatus,
-  externalRecordingId,
-  requestedAt,
-  transcript,
-}: {
-  callRecordingId: string;
-  currentStatus: string | undefined;
-  externalRecordingId: string;
-  requestedAt: string;
-  transcript: unknown;
-}): Promise<ReconcileCallRecordingTranscriptArtifactResult> => {
-  const existingTranscriptMarker = parseTranscriptMarker(transcript);
-
-  if (
-    !isNull(transcript) &&
-    !isUndefined(transcript) &&
-    isUndefined(existingTranscriptMarker)
-  ) {
-    return buildEmptyTranscriptArtifactResult();
-  }
-
-  if (existingTranscriptMarker?.status === 'FAILED') {
-    return buildEmptyTranscriptArtifactResult();
-  }
-
-  const listResult = await listRecallTranscripts({ externalRecordingId });
-
-  if (!listResult.ok) {
-    console.warn(
-      `[call-recorder] failed to list Recall transcripts for recording ${externalRecordingId}: ${listResult.errorMessage}`,
-    );
-
-    return buildEmptyTranscriptArtifactResult();
-  }
-
-  const transcriptArtifact = selectRecallTranscriptArtifact(
-    listResult.transcripts,
-  );
-  const pendingTranscriptMarkerRecallTranscriptId =
-    existingTranscriptMarker?.status === 'PENDING'
-      ? (existingTranscriptMarker.recallTranscriptId ?? undefined)
-      : undefined;
-  const transcriptIdToDownload =
-    transcriptArtifact?.id ?? pendingTranscriptMarkerRecallTranscriptId;
-
-  if (
-    isUndefined(transcriptArtifact) &&
-    isUndefined(pendingTranscriptMarkerRecallTranscriptId)
-  ) {
-    const createResult = await createAsyncRecallTranscript({
-      externalRecordingId,
-    });
-
-    if (!createResult.ok) {
-      console.warn(
-        `[call-recorder] failed to request transcript for Recall recording ${externalRecordingId}: ${createResult.errorMessage}`,
-      );
-
-      return buildEmptyTranscriptArtifactResult();
-    }
-
-    return {
-      updateData: {
-        transcript: buildPendingTranscriptMarker({
-          recallTranscriptId: createResult.transcriptId,
-          requestedAt,
-        }),
-      },
-      requestedTranscript: true,
-    };
-  }
-
-  if (
-    !isUndefined(transcriptArtifact) &&
-    (transcriptArtifact.statusCode === 'failed' ||
-      transcriptArtifact.statusCode === 'error')
-  ) {
-    return {
-      updateData: buildTranscriptFailureUpdate({
-        currentStatus,
-        transcriptId: transcriptArtifact.id,
-        subCode: transcriptArtifact.statusSubCode ?? null,
-      }),
-      requestedTranscript: false,
-    };
-  }
-
-  if (
-    !isUndefined(transcriptArtifact) &&
-    transcriptArtifact.statusCode !== 'done'
-  ) {
-    return buildEmptyTranscriptArtifactResult();
-  }
-
-  if (isUndefined(transcriptIdToDownload)) {
-    return buildEmptyTranscriptArtifactResult();
-  }
-
-  const downloadResult = await downloadTranscript({
-    transcriptId: transcriptIdToDownload,
-  });
-
-  if (downloadResult.outcome === 'filled') {
-    return {
-      updateData: {
-        transcript: downloadResult.content as Record<string, unknown>,
-      },
-      requestedTranscript: false,
-    };
-  }
-
-  if (downloadResult.outcome === 'failed') {
-    return {
-      updateData: buildTranscriptFailureUpdate({
-        currentStatus,
-        transcriptId: transcriptIdToDownload,
-        subCode: downloadResult.subCode,
-      }),
-      requestedTranscript: false,
-    };
-  }
-
-  if (downloadResult.outcome === 'error') {
-    console.warn(
-      `[call-recorder] could not fill transcript for call recording ${callRecordingId}: ${downloadResult.errorMessage}`,
-    );
-  }
-
-  return buildEmptyTranscriptArtifactResult();
-};
-
-const buildEmptyTranscriptArtifactResult =
-  (): ReconcileCallRecordingTranscriptArtifactResult => ({
-    updateData: {},
-    requestedTranscript: false,
-  });
-
-const selectRecallTranscriptArtifact = (
-  transcripts: RecallTranscriptSummary[],
-): RecallTranscriptSummary | undefined =>
-  transcripts.find((transcript) => transcript.statusCode !== 'deleted');
-
-const buildTranscriptFailureUpdate = ({
-  currentStatus,
-  transcriptId,
-  subCode,
-}: {
-  currentStatus: string | undefined;
-  transcriptId: string;
-  subCode: string | null;
-}): CallRecordingTranscriptArtifactUpdateFields => ({
-  transcript: buildFailedTranscriptMarker({
-    recallTranscriptId: transcriptId,
-    subCode,
-  }),
-  callRecorderFailureReason: buildTranscriptFailureReason(subCode),
-  ...(isCallRecordingStatusDowngrade({
-    fromStatus: currentStatus,
-    toStatus: CallRecordingStatus.FAILED,
-  })
-    ? {}
-    : { status: CallRecordingStatus.FAILED }),
-});