@twentyhq/call-recorder 1.0.1 → 1.0.2

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

@@ -1,225 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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'),
-    );
-  });
-});