@twentyhq/call-recorder 1.0.0

package/src/logic-functions/data/__tests__/complete-call-recording-ingestion.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { completeCallRecordingIngestion } from 'src/logic-functions/data/complete-call-recording-ingestion.util';
+
+describe('completeCallRecordingIngestion', () => {
+  it('guards the flip with non-terminal statuses and returns true when the row is claimed', async () => {
+    let capturedArgs: { filter: unknown; data: unknown } | undefined;
+    const mutation = vi.fn(async (mutationArg: any) => {
+      capturedArgs = mutationArg.updateCallRecordings.__args;
+
+      return { updateCallRecordings: [{ id: 'call-recording-1' }] };
+    });
+
+    const claimed = await completeCallRecordingIngestion(
+      { mutation } as never,
+      {
+        id: 'call-recording-1',
+      },
+    );
+
+    expect(claimed).toBe(true);
+    expect(mutation).toHaveBeenCalledTimes(1);
+    expect(capturedArgs?.filter).toEqual({
+      id: { eq: 'call-recording-1' },
+      status: { in: ['SCHEDULED', 'JOINING', 'RECORDING', 'PROCESSING'] },
+    });
+    expect(capturedArgs?.data).toEqual({ status: 'COMPLETED' });
+  });
+
+  it('returns false when the row was already COMPLETED, so the loser cannot charge', async () => {
+    const mutation = vi.fn(async () => ({ updateCallRecordings: [] }));
+
+    const claimed = await completeCallRecordingIngestion(
+      { mutation } as never,
+      {
+        id: 'call-recording-1',
+      },
+    );
+
+    expect(claimed).toBe(false);
+  });
+
+  it('returns false when the API omits the result list', async () => {
+    const mutation = vi.fn(async () => ({}));
+
+    const claimed = await completeCallRecordingIngestion(
+      { mutation } as never,
+      {
+        id: 'call-recording-1',
+      },
+    );
+
+    expect(claimed).toBe(false);
+  });
+});

package/src/logic-functions/data/__tests__/fetch-all-nodes.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { fetchAllNodes } from 'src/logic-functions/data/fetch-all-nodes.util';
+
+describe('fetchAllNodes', () => {
+  it('collects nodes across pages until hasNextPage is false', async () => {
+    const fetchPage = vi
+      .fn()
+      .mockResolvedValueOnce({
+        pageInfo: { hasNextPage: true, endCursor: 'cursor-1' },
+        edges: [{ node: 'node-1' }, { node: 'node-2' }],
+      })
+      .mockResolvedValueOnce({
+        pageInfo: { hasNextPage: false, endCursor: 'cursor-2' },
+        edges: [{ node: 'node-3' }],
+      });
+
+    const nodes = await fetchAllNodes<string>(fetchPage);
+
+    expect(nodes).toEqual(['node-1', 'node-2', 'node-3']);
+    expect(fetchPage).toHaveBeenNthCalledWith(1, undefined);
+    expect(fetchPage).toHaveBeenNthCalledWith(2, 'cursor-1');
+  });
+
+  it('throws when hasNextPage is true without an endCursor', async () => {
+    const fetchPage = vi.fn().mockResolvedValue({
+      pageInfo: { hasNextPage: true, endCursor: null },
+      edges: [{ node: 'node-1' }],
+    });
+
+    await expect(fetchAllNodes<string>(fetchPage)).rejects.toThrow(
+      'Inconsistent pagination state: hasNextPage is true without an endCursor',
+    );
+  });
+
+  it('throws when the query returns no connection', async () => {
+    const fetchPage = vi.fn().mockResolvedValue(undefined);
+
+    await expect(fetchAllNodes<string>(fetchPage)).rejects.toThrow(
+      'Pagination query returned no connection',
+    );
+  });
+});

package/src/logic-functions/data/__tests__/get-current-workspace-id.test.ts

@@ -0,0 +1,38 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { getCurrentWorkspaceId } from 'src/logic-functions/data/get-current-workspace-id.util';
+
+const APP_ACCESS_TOKEN_ENV_VAR_NAME = 'TWENTY_APP_ACCESS_TOKEN';
+const ORIGINAL_APP_ACCESS_TOKEN = process.env[APP_ACCESS_TOKEN_ENV_VAR_NAME];
+const WORKSPACE_ID = '123e4567-e89b-12d3-a456-426614174000';
+
+const restoreOriginalAppAccessToken = () => {
+  if (ORIGINAL_APP_ACCESS_TOKEN === undefined) {
+    delete process.env[APP_ACCESS_TOKEN_ENV_VAR_NAME];
+
+    return;
+  }
+
+  process.env[APP_ACCESS_TOKEN_ENV_VAR_NAME] = ORIGINAL_APP_ACCESS_TOKEN;
+};
+
+const buildAccessToken = (payload: Record<string, unknown>): string =>
+  [
+    Buffer.from(JSON.stringify({ alg: 'none' })).toString('base64url'),
+    Buffer.from(JSON.stringify(payload)).toString('base64url'),
+    'signature',
+  ].join('.');
+
+describe('getCurrentWorkspaceId', () => {
+  afterEach(() => {
+    restoreOriginalAppAccessToken();
+  });
+
+  it('reads the workspace id from the app access token payload', () => {
+    process.env[APP_ACCESS_TOKEN_ENV_VAR_NAME] = buildAccessToken({
+      workspaceId: WORKSPACE_ID,
+    });
+
+    expect(getCurrentWorkspaceId()).toBe(WORKSPACE_ID);
+  });
+});

package/src/logic-functions/data/__tests__/strip-restricted-field-value.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+
+import { RESTRICTED_FIELD_PLACEHOLDER } from 'src/logic-functions/constants/restricted-field-placeholder';
+import { stripRestrictedFieldValue } from 'src/logic-functions/data/strip-restricted-field-value.util';
+
+describe('stripRestrictedFieldValue', () => {
+  it('drops the calendar visibility restriction placeholder', () => {
+    expect(
+      stripRestrictedFieldValue(RESTRICTED_FIELD_PLACEHOLDER),
+    ).toBeUndefined();
+  });
+
+  it('keeps regular values', () => {
+    expect(stripRestrictedFieldValue('Customer Discovery Call')).toBe(
+      'Customer Discovery Call',
+    );
+  });
+
+  it('keeps undefined', () => {
+    expect(stripRestrictedFieldValue(undefined)).toBeUndefined();
+  });
+});

package/src/logic-functions/data/complete-call-recording-ingestion.util.ts

@@ -0,0 +1,24 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
+import { NON_TERMINAL_CALL_RECORDING_STATUSES } from 'src/logic-functions/constants/non-terminal-call-recording-statuses';
+
+export const completeCallRecordingIngestion = async (
+  client: CoreApiClient,
+  { id }: { id: string },
+): Promise<boolean> => {
+  const result = await client.mutation({
+    updateCallRecordings: {
+      __args: {
+        filter: {
+          id: { eq: id },
+          status: { in: NON_TERMINAL_CALL_RECORDING_STATUSES },
+        },
+        data: { status: CallRecordingStatus.COMPLETED },
+      },
+      id: true,
+    },
+  });
+
+  return (result.updateCallRecordings ?? []).length > 0;
+};

package/src/logic-functions/data/create-call-recording.util.ts

@@ -0,0 +1,41 @@
+import { isUndefined } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CallRecordingRequestStatus } from 'src/logic-functions/constants/call-recording-request-status';
+import { type CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
+
+export type ScheduledCallRecordingFields = {
+  title: string | null;
+  status: CallRecordingStatus.SCHEDULED;
+  recordingRequestStatus: CallRecordingRequestStatus.REQUESTED;
+  calendarEventId: string;
+};
+
+export const createCallRecording = async (
+  client: CoreApiClient,
+  {
+    id,
+    data,
+  }: {
+    id: string;
+    data: ScheduledCallRecordingFields;
+  },
+): Promise<string> => {
+  const mutationResult = await client.mutation({
+    createCallRecording: {
+      __args: {
+        data: { id, ...data },
+      },
+      id: true,
+    },
+  });
+  const createdCallRecordingId = mutationResult.createCallRecording?.id;
+
+  if (isUndefined(createdCallRecordingId)) {
+    throw new Error(
+      'createCallRecording mutation did not return a call recording id',
+    );
+  }
+
+  return createdCallRecordingId;
+};

package/src/logic-functions/data/fetch-all-nodes.util.ts

@@ -0,0 +1,44 @@
+import { isString, isUndefined } from '@sniptt/guards';
+
+export type ConnectionPage<TNode> = {
+  pageInfo?: {
+    hasNextPage?: boolean | null;
+    endCursor?: string | null;
+  } | null;
+  edges?: Array<{ node: TNode }> | null;
+};
+
+export const fetchAllNodes = async <TNode>(
+  fetchPage: (
+    afterCursor: string | undefined,
+  ) => Promise<ConnectionPage<TNode> | undefined>,
+): Promise<TNode[]> => {
+  const nodes: TNode[] = [];
+  let hasNextPage = true;
+  let afterCursor: string | undefined;
+
+  while (hasNextPage) {
+    const connection = await fetchPage(afterCursor);
+
+    if (isUndefined(connection)) {
+      throw new Error('Pagination query returned no connection');
+    }
+
+    for (const edge of connection.edges ?? []) {
+      nodes.push(edge.node);
+    }
+
+    hasNextPage = connection.pageInfo?.hasNextPage === true;
+    const endCursor = connection.pageInfo?.endCursor;
+
+    if (hasNextPage && !isString(endCursor)) {
+      throw new Error(
+        'Inconsistent pagination state: hasNextPage is true without an endCursor',
+      );
+    }
+
+    afterCursor = isString(endCursor) ? endCursor : undefined;
+  }
+
+  return nodes;
+};

package/src/logic-functions/data/fetch-calendar-events-by-filter.util.ts

@@ -0,0 +1,80 @@
+import { isString, isUndefined } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { TWENTY_PAGE_SIZE } from 'src/logic-functions/constants/twenty-page-size';
+import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';
+import {
+  fetchAllNodes,
+  type ConnectionPage,
+} from 'src/logic-functions/data/fetch-all-nodes.util';
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+import { stripRestrictedFieldValue } from 'src/logic-functions/data/strip-restricted-field-value.util';
+
+type CalendarEventNode = {
+  id: string;
+  title?: string | null;
+  isCanceled?: boolean | null;
+  startsAt?: string | null;
+  endsAt?: string | null;
+  iCalUid?: string | null;
+  conferenceLink?: { primaryLinkUrl?: string | null } | null;
+  callRecorderPreference?: string | null;
+};
+
+export const fetchCalendarEventsByFilter = async (
+  client: CoreApiClient,
+  filter: Record<string, unknown>,
+): Promise<CalendarEventRecord[]> => {
+  const calendarEventNodes = await fetchAllNodes<CalendarEventNode>(
+    async (afterCursor) => {
+      const queryResult = await client.query({
+        calendarEvents: {
+          __args: {
+            filter,
+            first: TWENTY_PAGE_SIZE,
+            ...(isUndefined(afterCursor) ? {} : { after: afterCursor }),
+          },
+          pageInfo: {
+            hasNextPage: true,
+            endCursor: true,
+          },
+          edges: {
+            node: {
+              id: true,
+              title: true,
+              isCanceled: true,
+              startsAt: true,
+              endsAt: true,
+              iCalUid: true,
+              conferenceLink: {
+                primaryLinkUrl: true,
+              },
+              callRecorderPreference: true,
+            },
+          },
+        },
+      });
+
+      return queryResult.calendarEvents as
+        | ConnectionPage<CalendarEventNode>
+        | undefined;
+    },
+  );
+
+  return calendarEventNodes.map((calendarEvent) => ({
+    id: calendarEvent.id,
+    title: stripRestrictedFieldValue(calendarEvent.title ?? undefined),
+    isCanceled: calendarEvent.isCanceled ?? false,
+    startsAt: calendarEvent.startsAt ?? undefined,
+    endsAt: calendarEvent.endsAt ?? undefined,
+    iCalUid: calendarEvent.iCalUid ?? undefined,
+    conferenceLinkUrl: isNonEmptyString(
+      calendarEvent.conferenceLink?.primaryLinkUrl,
+    )
+      ? calendarEvent.conferenceLink.primaryLinkUrl
+      : undefined,
+    callRecorderPreference: isString(calendarEvent.callRecorderPreference)
+      ? calendarEvent.callRecorderPreference
+      : undefined,
+  }));
+};

package/src/logic-functions/data/fetch-calendar-events-by-ids.util.ts

@@ -0,0 +1,20 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';
+import { fetchCalendarEventsByFilter } from 'src/logic-functions/data/fetch-calendar-events-by-filter.util';
+import { getUniqueSortedIds } from 'src/logic-functions/utils/get-unique-sorted-ids.util';
+
+export const fetchCalendarEventsByIds = async (
+  client: CoreApiClient,
+  calendarEventIds: string[],
+): Promise<CalendarEventRecord[]> => {
+  const uniqueCalendarEventIds = getUniqueSortedIds(calendarEventIds);
+
+  if (uniqueCalendarEventIds.length === 0) {
+    return [];
+  }
+
+  return fetchCalendarEventsByFilter(client, {
+    id: { in: uniqueCalendarEventIds },
+  });
+};

package/src/logic-functions/data/fetch-calendar-events-by-starts-at-values.util.ts

@@ -0,0 +1,19 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';
+import { fetchCalendarEventsByFilter } from 'src/logic-functions/data/fetch-calendar-events-by-filter.util';
+
+export const fetchCalendarEventsByStartsAtValues = async (
+  client: CoreApiClient,
+  startsAtValues: string[],
+): Promise<CalendarEventRecord[]> => {
+  const uniqueStartsAtValues = [...new Set(startsAtValues)].sort();
+
+  if (uniqueStartsAtValues.length === 0) {
+    return [];
+  }
+
+  return fetchCalendarEventsByFilter(client, {
+    startsAt: { in: uniqueStartsAtValues },
+  });
+};

package/src/logic-functions/data/find-call-recordings-by-calendar-event-ids.util.ts

@@ -0,0 +1,17 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';
+import { findCallRecordingsByFilter } from 'src/logic-functions/data/find-call-recordings-by-filter.util';
+
+export const findCallRecordingsByCalendarEventIds = async (
+  client: CoreApiClient,
+  calendarEventIds: string[],
+): Promise<CallRecordingRecord[]> => {
+  if (calendarEventIds.length === 0) {
+    return [];
+  }
+
+  return findCallRecordingsByFilter(client, {
+    calendarEventId: { in: calendarEventIds },
+  });
+};

package/src/logic-functions/data/find-call-recordings-by-filter.util.ts

@@ -0,0 +1,102 @@
+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 { TWENTY_PAGE_SIZE } from 'src/logic-functions/constants/twenty-page-size';
+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';
+import {
+  fetchAllNodes,
+  type ConnectionPage,
+} from 'src/logic-functions/data/fetch-all-nodes.util';
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+
+type CallRecordingNode = {
+  id: string;
+  title?: string | null;
+  status?: string | null;
+  recordingRequestStatus?: unknown;
+  startedAt?: string | null;
+  endedAt?: string | null;
+  calendarEventId?: string | null;
+  externalBotId?: string | null;
+  externalRecordingId?: string | null;
+  callRecorderFailureReason?: string | null;
+};
+
+export const findCallRecordingsByFilter = async (
+  client: CoreApiClient,
+  filter: Record<string, unknown>,
+): Promise<CallRecordingRecord[]> => {
+  const callRecordingNodes = await fetchAllNodes<CallRecordingNode>(
+    async (afterCursor) => {
+      const queryResult = await client.query({
+        callRecordings: {
+          __args: {
+            filter,
+            first: TWENTY_PAGE_SIZE,
+            ...(isUndefined(afterCursor) ? {} : { after: afterCursor }),
+          },
+          pageInfo: {
+            hasNextPage: true,
+            endCursor: true,
+          },
+          edges: {
+            node: {
+              id: true,
+              title: true,
+              status: true,
+              recordingRequestStatus: true,
+              startedAt: true,
+              endedAt: true,
+              calendarEventId: true,
+              externalBotId: true,
+              externalRecordingId: true,
+              callRecorderFailureReason: true,
+            },
+          },
+        },
+      });
+
+      return queryResult.callRecordings as
+        | ConnectionPage<CallRecordingNode>
+        | undefined;
+    },
+  );
+
+  return callRecordingNodes.map((callRecording) => ({
+    id: callRecording.id,
+    title: callRecording.title ?? undefined,
+    status: callRecording.status ?? undefined,
+    recordingRequestStatus: normalizeCallRecordingRequestStatus(
+      callRecording.recordingRequestStatus,
+    ),
+    startedAt: callRecording.startedAt ?? undefined,
+    endedAt: callRecording.endedAt ?? undefined,
+    calendarEventId: callRecording.calendarEventId ?? undefined,
+    externalBotId: normalizeOptionalString(callRecording.externalBotId),
+    externalRecordingId: normalizeOptionalString(
+      callRecording.externalRecordingId,
+    ),
+    callRecorderFailureReason: normalizeOptionalString(
+      callRecording.callRecorderFailureReason,
+    ),
+  }));
+};
+
+const normalizeOptionalString = (
+  value: string | null | undefined,
+): string | undefined => (isNonEmptyString(value) ? value : undefined);
+
+const normalizeCallRecordingRequestStatus = (
+  recordingRequestStatus: unknown,
+): CallRecordingRequestStatus | undefined => {
+  if (recordingRequestStatus === CallRecordingRequestStatus.REQUESTED) {
+    return recordingRequestStatus;
+  }
+
+  if (recordingRequestStatus === CallRecordingRequestStatus.CANCELED) {
+    return recordingRequestStatus;
+  }
+
+  return undefined;
+};

package/src/logic-functions/data/find-call-recordings-by-ids.util.ts

@@ -0,0 +1,17 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';
+import { findCallRecordingsByFilter } from 'src/logic-functions/data/find-call-recordings-by-filter.util';
+
+export const findCallRecordingsByIds = async (
+  client: CoreApiClient,
+  callRecordingIds: string[],
+): Promise<CallRecordingRecord[]> => {
+  if (callRecordingIds.length === 0) {
+    return [];
+  }
+
+  return findCallRecordingsByFilter(client, {
+    id: { in: callRecordingIds },
+  });
+};

package/src/logic-functions/data/find-open-scheduled-call-recordings.util.ts

@@ -0,0 +1,14 @@
+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 CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';
+import { findCallRecordingsByFilter } from 'src/logic-functions/data/find-call-recordings-by-filter.util';
+
+export const findOpenScheduledCallRecordings = async (
+  client: CoreApiClient,
+): Promise<CallRecordingRecord[]> =>
+  findCallRecordingsByFilter(client, {
+    recordingRequestStatus: { eq: CallRecordingRequestStatus.REQUESTED },
+    status: { eq: CallRecordingStatus.SCHEDULED },
+  });

package/src/logic-functions/data/get-current-workspace-id.util.ts

@@ -0,0 +1,36 @@
+import { isUndefined } from '@sniptt/guards';
+
+import { asRecord } from 'src/logic-functions/utils/as-record.util';
+import { getString } from 'src/logic-functions/utils/get-string.util';
+
+const APP_ACCESS_TOKEN_ENV_VAR_NAME = 'TWENTY_APP_ACCESS_TOKEN';
+
+export const getCurrentWorkspaceId = (): string | undefined => {
+  const accessToken = getString(process.env[APP_ACCESS_TOKEN_ENV_VAR_NAME]);
+
+  if (isUndefined(accessToken)) {
+    return undefined;
+  }
+
+  return getWorkspaceIdFromAccessToken(accessToken);
+};
+
+const getWorkspaceIdFromAccessToken = (
+  accessToken: string,
+): string | undefined => {
+  const encodedPayload = accessToken.split('.')[1];
+
+  if (isUndefined(encodedPayload)) {
+    return undefined;
+  }
+
+  try {
+    const payload = asRecord(
+      JSON.parse(Buffer.from(encodedPayload, 'base64url').toString('utf8')),
+    );
+
+    return getString(payload?.workspaceId);
+  } catch {
+    return undefined;
+  }
+};

package/src/logic-functions/data/strip-restricted-field-value.util.ts

@@ -0,0 +1,6 @@
+import { RESTRICTED_FIELD_PLACEHOLDER } from 'src/logic-functions/constants/restricted-field-placeholder';
+
+export const stripRestrictedFieldValue = (
+  value: string | undefined,
+): string | undefined =>
+  value === RESTRICTED_FIELD_PLACEHOLDER ? undefined : value;

package/src/logic-functions/data/update-call-recording.util.ts

@@ -0,0 +1,24 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CallRecordingUpdateFields } from 'src/logic-functions/types/call-recording-update-fields.type';
+
+export const updateCallRecording = async (
+  client: CoreApiClient,
+  {
+    id,
+    data,
+  }: {
+    id: string;
+    data: CallRecordingUpdateFields;
+  },
+): Promise<void> => {
+  await client.mutation({
+    updateCallRecording: {
+      __args: {
+        id,
+        data,
+      },
+      id: true,
+    },
+  });
+};

package/src/logic-functions/domain/__tests__/build-call-recorder-policy-result.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildCallRecorderPolicyResult } from 'src/logic-functions/domain/build-call-recorder-policy-result.util';
+import { type CallRecorderPolicyCalendarEventInput } from 'src/logic-functions/types/call-recorder-policy-calendar-event-input.type';
+
+const NOW = new Date('2026-01-01T12:00:00.000Z');
+
+const buildCalendarEventInput = (
+  overrides: Partial<CallRecorderPolicyCalendarEventInput>,
+): CallRecorderPolicyCalendarEventInput => ({
+  id: 'calendar-event-1',
+  isCanceled: false,
+  startsAt: '2026-01-01T13:00:00.000Z',
+  endsAt: '2026-01-01T14:00:00.000Z',
+  iCalUid: 'ical-uid-1',
+  conferenceLinkUrl: 'https://meet.example.com/customer-sync',
+  callRecorderPreference: undefined,
+  ...overrides,
+});
+
+describe('buildCallRecorderPolicyResult', () => {
+  it('requests a bot for the ON wire value', () => {
+    const policyResult = buildCallRecorderPolicyResult(
+      buildCalendarEventInput({
+        callRecorderPreference: 'ON',
+      }),
+      NOW,
+    );
+
+    expect(policyResult.callRecorderPreference).toBe('ON');
+    expect(policyResult.shouldRequestBot).toBe(true);
+    expect(policyResult.reason).toBe('RECORDING_ENABLED');
+  });
+
+  it('does not request a bot for the OFF wire value', () => {
+    const policyResult = buildCallRecorderPolicyResult(
+      buildCalendarEventInput({
+        callRecorderPreference: 'OFF',
+      }),
+      NOW,
+    );
+
+    expect(policyResult.callRecorderPreference).toBe('OFF');
+    expect(policyResult.shouldRequestBot).toBe(false);
+    expect(policyResult.reason).toBe('PREFERENCE_OFF');
+  });
+});