@twentyhq/call-recorder 1.0.0

package/src/logic-functions/flows/__tests__/heal-call-recordings-missing-bot.test.ts

@@ -0,0 +1,225 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { healCallRecordingsMissingBot } from 'src/logic-functions/flows/heal-call-recordings-missing-bot.util';
+
+const scheduleRecallBotMock = vi.hoisted(() => vi.fn());
+const getCurrentWorkspaceIdMock = vi.hoisted(() => vi.fn());
+
+vi.mock('src/logic-functions/data/get-current-workspace-id.util', () => ({
+  getCurrentWorkspaceId: getCurrentWorkspaceIdMock,
+}));
+
+vi.mock('src/logic-functions/recall-api/schedule-recall-bot.util', () => ({
+  scheduleRecallBot: scheduleRecallBotMock,
+}));
+
+const NOW = new Date('2026-01-01T12:00:00.000Z');
+const WORKSPACE_ID = '123e4567-e89b-12d3-a456-426614174000';
+const UPCOMING_STARTS_AT = '2026-01-01T13:00:00.000Z';
+const UPCOMING_ENDS_AT = '2026-01-01T14:00:00.000Z';
+const PAST_STARTS_AT = '2026-01-01T10:00:00.000Z';
+const PAST_ENDS_AT = '2026-01-01T11:00:00.000Z';
+
+type CallRecordingNode = {
+  id: string;
+  status?: string;
+  recordingRequestStatus?: string | null;
+  calendarEventId?: string | null;
+  externalBotId?: string | null;
+};
+
+type CalendarEventNode = {
+  id: string;
+  startsAt?: string | null;
+  endsAt?: string | null;
+  iCalUid?: string | null;
+  conferenceLink?: { primaryLinkUrl?: string | null } | null;
+};
+
+class FakeCoreApiClient {
+  callRecordings: CallRecordingNode[];
+  calendarEvents: CalendarEventNode[];
+
+  constructor({
+    callRecordings = [],
+    calendarEvents = [],
+  }: {
+    callRecordings?: CallRecordingNode[];
+    calendarEvents?: CalendarEventNode[];
+  }) {
+    this.callRecordings = callRecordings;
+    this.calendarEvents = calendarEvents;
+  }
+
+  async query(query: any): Promise<any> {
+    if (query.callRecordings !== undefined) {
+      const filter = query.callRecordings.__args.filter;
+      const matches =
+        filter.id?.in !== undefined
+          ? this.callRecordings.filter((callRecording) =>
+              filter.id.in.includes(callRecording.id),
+            )
+          : this.callRecordings.filter(
+              (callRecording) =>
+                callRecording.recordingRequestStatus ===
+                  filter.recordingRequestStatus.eq &&
+                callRecording.status === filter.status.eq,
+            );
+
+      return { callRecordings: buildConnection(matches) };
+    }
+
+    if (query.calendarEvents !== undefined) {
+      const calendarEventIds = query.calendarEvents.__args.filter.id.in;
+
+      return {
+        calendarEvents: buildConnection(
+          this.calendarEvents.filter((calendarEvent) =>
+            calendarEventIds.includes(calendarEvent.id),
+          ),
+        ),
+      };
+    }
+
+    throw new Error(`Unhandled query: ${JSON.stringify(query)}`);
+  }
+
+  async mutation(mutation: any): Promise<any> {
+    if (mutation.updateCallRecording !== undefined) {
+      const { id, data } = mutation.updateCallRecording.__args;
+      const callRecording = this.callRecordings.find(
+        (candidate) => candidate.id === id,
+      );
+
+      if (callRecording !== undefined) {
+        Object.assign(callRecording, data);
+      }
+
+      return { updateCallRecording: { id } };
+    }
+
+    throw new Error(`Unhandled mutation: ${JSON.stringify(mutation)}`);
+  }
+}
+
+const buildConnection = <Node>(nodes: Node[]) => ({
+  pageInfo: { hasNextPage: false, endCursor: undefined },
+  edges: nodes.map((node) => ({ node })),
+});
+
+const buildBotlessCallRecording = (
+  overrides: Partial<CallRecordingNode> = {},
+): CallRecordingNode => ({
+  id: 'call-recording-1',
+  status: 'SCHEDULED',
+  recordingRequestStatus: 'REQUESTED',
+  calendarEventId: 'calendar-event-1',
+  externalBotId: null,
+  ...overrides,
+});
+
+const buildCalendarEvent = (
+  overrides: Partial<CalendarEventNode> = {},
+): CalendarEventNode => ({
+  id: 'calendar-event-1',
+  startsAt: UPCOMING_STARTS_AT,
+  endsAt: UPCOMING_ENDS_AT,
+  iCalUid: 'calendar-event-uid',
+  conferenceLink: { primaryLinkUrl: 'https://meet.example.com/customer-sync' },
+  ...overrides,
+});
+
+describe('healCallRecordingsMissingBot', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    getCurrentWorkspaceIdMock.mockReset();
+    getCurrentWorkspaceIdMock.mockReturnValue(WORKSPACE_ID);
+    scheduleRecallBotMock.mockReset();
+    scheduleRecallBotMock.mockResolvedValue({
+      ok: true,
+      externalBotId: 'recall-bot-1',
+    });
+  });
+
+  it('schedules a bot and writes the id for an upcoming botless recording', async () => {
+    const client = new FakeCoreApiClient({
+      callRecordings: [buildBotlessCallRecording()],
+      calendarEvents: [buildCalendarEvent()],
+    });
+
+    const result = await healCallRecordingsMissingBot({
+      client: client as unknown as CoreApiClient,
+      now: NOW,
+    });
+
+    expect(result.scheduledCallRecordingIds).toEqual(['call-recording-1']);
+    expect(scheduleRecallBotMock).toHaveBeenCalledTimes(1);
+    expect(scheduleRecallBotMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          twentyWorkspaceId: WORKSPACE_ID,
+        }),
+      }),
+    );
+    expect(client.callRecordings[0].externalBotId).toBe('recall-bot-1');
+  });
+
+  it('does not report a recording as scheduled when Recall scheduling fails', async () => {
+    scheduleRecallBotMock.mockResolvedValue({
+      ok: false,
+      status: 500,
+      errorMessage: 'Recall API responded with HTTP 500',
+    });
+    const client = new FakeCoreApiClient({
+      callRecordings: [buildBotlessCallRecording()],
+      calendarEvents: [buildCalendarEvent()],
+    });
+
+    const result = await healCallRecordingsMissingBot({
+      client: client as unknown as CoreApiClient,
+      now: NOW,
+    });
+
+    expect(result.scheduledCallRecordingIds).toEqual([]);
+    expect(scheduleRecallBotMock).toHaveBeenCalledTimes(1);
+    expect(client.callRecordings[0].externalBotId).toBeNull();
+  });
+
+  it('skips a recording whose meeting has already ended', async () => {
+    const client = new FakeCoreApiClient({
+      callRecordings: [buildBotlessCallRecording()],
+      calendarEvents: [
+        buildCalendarEvent({
+          startsAt: PAST_STARTS_AT,
+          endsAt: PAST_ENDS_AT,
+        }),
+      ],
+    });
+
+    const result = await healCallRecordingsMissingBot({
+      client: client as unknown as CoreApiClient,
+      now: NOW,
+    });
+
+    expect(result.scheduledCallRecordingIds).toEqual([]);
+    expect(scheduleRecallBotMock).not.toHaveBeenCalled();
+  });
+
+  it('does nothing when every scheduled recording already has a bot', async () => {
+    const client = new FakeCoreApiClient({
+      callRecordings: [
+        buildBotlessCallRecording({ externalBotId: 'recall-bot-existing' }),
+      ],
+      calendarEvents: [buildCalendarEvent()],
+    });
+
+    const result = await healCallRecordingsMissingBot({
+      client: client as unknown as CoreApiClient,
+      now: NOW,
+    });
+
+    expect(result.scheduledCallRecordingIds).toEqual([]);
+    expect(scheduleRecallBotMock).not.toHaveBeenCalled();
+  });
+});

package/src/logic-functions/flows/__tests__/ingest-call-recording-media.test.ts

@@ -0,0 +1,153 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ingestCallRecordingMedia } from 'src/logic-functions/flows/ingest-call-recording-media.util';
+
+const uploadFileMock = vi.hoisted(() => vi.fn());
+const getRecallRecordingMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-client-sdk/metadata', () => ({
+  MetadataApiClient: class {
+    uploadFile = uploadFileMock;
+  },
+}));
+
+vi.mock('src/logic-functions/recall-api/get-recall-recording.util', () => ({
+  getRecallRecording: getRecallRecordingMock,
+}));
+
+const RECORDING_WITH_MEDIA = {
+  id: 'recall-recording-1',
+  media_shortcuts: {
+    video_mixed: { download_url: 'https://media.example.com/video.mp4' },
+    audio_mixed: { download_url: 'https://media.example.com/audio.mp3' },
+  },
+};
+
+const buildFetchResponse = () => ({
+  ok: true,
+  headers: { get: () => 'video/mp4' },
+  arrayBuffer: async () => new ArrayBuffer(8),
+});
+
+describe('ingestCallRecordingMedia', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    uploadFileMock.mockReset();
+    getRecallRecordingMock.mockReset();
+    getRecallRecordingMock.mockResolvedValue({
+      ok: true,
+      recording: RECORDING_WITH_MEDIA,
+    });
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(buildFetchResponse()));
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('downloads and uploads every missing artifact', async () => {
+    uploadFileMock
+      .mockResolvedValueOnce({ id: 'file-video-1' })
+      .mockResolvedValueOnce({ id: 'file-audio-1' });
+
+    const updateFields = await ingestCallRecordingMedia({
+      callRecordingId: 'call-recording-1',
+      externalRecordingId: 'recall-recording-1',
+      hasAudio: false,
+      hasVideo: false,
+    });
+
+    expect(updateFields).toEqual({
+      video: [{ fileId: 'file-video-1', label: 'video.mp4' }],
+      audio: [{ fileId: 'file-audio-1', label: 'audio.mp3' }],
+    });
+    expect(uploadFileMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('skips artifacts already on the record', async () => {
+    uploadFileMock.mockResolvedValue({ id: 'file-audio-1' });
+
+    const updateFields = await ingestCallRecordingMedia({
+      callRecordingId: 'call-recording-1',
+      externalRecordingId: 'recall-recording-1',
+      hasAudio: false,
+      hasVideo: true,
+    });
+
+    expect(updateFields).toEqual({
+      audio: [{ fileId: 'file-audio-1', label: 'audio.mp3' }],
+    });
+    expect(uploadFileMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not fetch the recording when both artifacts are present', async () => {
+    const updateFields = await ingestCallRecordingMedia({
+      callRecordingId: 'call-recording-1',
+      externalRecordingId: 'recall-recording-1',
+      hasAudio: true,
+      hasVideo: true,
+    });
+
+    expect(updateFields).toEqual({});
+    expect(getRecallRecordingMock).not.toHaveBeenCalled();
+    expect(uploadFileMock).not.toHaveBeenCalled();
+  });
+
+  it('omits an artifact and warns when its transfer fails', async () => {
+    uploadFileMock.mockRejectedValueOnce(new Error('upload exploded'));
+    uploadFileMock.mockResolvedValueOnce({ id: 'file-audio-1' });
+
+    const updateFields = await ingestCallRecordingMedia({
+      callRecordingId: 'call-recording-1',
+      externalRecordingId: 'recall-recording-1',
+      hasAudio: false,
+      hasVideo: false,
+    });
+
+    expect(updateFields).toEqual({
+      audio: [{ fileId: 'file-audio-1', label: 'audio.mp3' }],
+    });
+    expect(Object.keys(updateFields)).toEqual(['audio']);
+    expect(console.warn).toHaveBeenCalledWith(
+      expect.stringContaining('upload exploded'),
+    );
+  });
+
+  it('returns nothing when the recording exposes no media urls', async () => {
+    getRecallRecordingMock.mockResolvedValue({
+      ok: true,
+      recording: { id: 'recall-recording-1' },
+    });
+
+    const updateFields = await ingestCallRecordingMedia({
+      callRecordingId: 'call-recording-1',
+      externalRecordingId: 'recall-recording-1',
+      hasAudio: false,
+      hasVideo: false,
+    });
+
+    expect(updateFields).toEqual({});
+    expect(uploadFileMock).not.toHaveBeenCalled();
+  });
+
+  it('warns and returns nothing when the recording fetch fails', async () => {
+    getRecallRecordingMock.mockResolvedValue({
+      ok: false,
+      status: 500,
+      errorMessage: 'recording boom',
+    });
+
+    const updateFields = await ingestCallRecordingMedia({
+      callRecordingId: 'call-recording-1',
+      externalRecordingId: 'recall-recording-1',
+      hasAudio: false,
+      hasVideo: false,
+    });
+
+    expect(updateFields).toEqual({});
+    expect(uploadFileMock).not.toHaveBeenCalled();
+    expect(console.warn).toHaveBeenCalledWith(
+      expect.stringContaining('recording boom'),
+    );
+  });
+});