The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Call recorder: sweep upcoming calendar events for recording bots on install (#22552)
nitin18c10f4632bd
diff --git a/packages/twenty-apps/public/call-recorder/src/constants/reconcile-upcoming-calendar-events-logic-function-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/reconcile-upcoming-calendar-events-logic-function-universal-identifier.tsnew file mode 100644index 00000000000..cb28e05b3f9--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/reconcile-upcoming-calendar-events-logic-function-universal-identifier.ts@@ -0,0 +1,2 @@+export const RECONCILE_UPCOMING_CALENDAR_EVENTS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =+ '06fafff7-c722-41d1-869d-9554736f4c53';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/reconcile-upcoming-calendar-events-route-path.ts b/packages/twenty-apps/public/call-recorder/src/constants/reconcile-upcoming-calendar-events-route-path.tsnew file mode 100644index 00000000000..7753b4eb64e--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/reconcile-upcoming-calendar-events-route-path.ts@@ -0,0 +1,2 @@+export const RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH =+ '/call-recorder/reconcile-upcoming-calendar-events';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/start-call-recording-summary-backfill-on-install-logic-function-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/start-call-recording-summary-backfill-on-install-logic-function-universal-identifier.tsdeleted file mode 100644index a54103eb3ab..00000000000--- a/packages/twenty-apps/public/call-recorder/src/constants/start-call-recording-summary-backfill-on-install-logic-function-universal-identifier.ts+++ /dev/null@@ -1,2 +0,0 @@-export const START_CALL_RECORDING_SUMMARY_BACKFILL_ON_INSTALL_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =- '53e0acb4-b761-40c9-8aaf-554d2a5da00f';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/start-post-install-backfills-logic-function-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/start-post-install-backfills-logic-function-universal-identifier.tsnew file mode 100644index 00000000000..8aa18debf41--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/start-post-install-backfills-logic-function-universal-identifier.ts@@ -0,0 +1,2 @@+export const START_POST_INSTALL_BACKFILLS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =+ '53e0acb4-b761-40c9-8aaf-554d2a5da00f';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/sweep-upcoming-calendar-events-logic-function-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/sweep-upcoming-calendar-events-logic-function-universal-identifier.tsnew file mode 100644index 00000000000..9187ad5f49e--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/sweep-upcoming-calendar-events-logic-function-universal-identifier.ts@@ -0,0 +1,2 @@+export const SWEEP_UPCOMING_CALENDAR_EVENTS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =+ '05ab984e-c6ad-4b1c-800f-8f029dc7aac8';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/twenty-functions-url-env-var-name.ts b/packages/twenty-apps/public/call-recorder/src/constants/twenty-functions-url-env-var-name.tsnew file mode 100644index 00000000000..ddd582a4c03--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/twenty-functions-url-env-var-name.ts@@ -0,0 +1 @@+export const TWENTY_FUNCTIONS_URL_ENV_VAR_NAME = 'TWENTY_FUNCTIONS_URL';diff --git a/packages/twenty-apps/public/call-recorder/src/front-components/utils/__tests__/request-call-recording-summary-generation.test.ts b/packages/twenty-apps/public/call-recorder/src/front-components/utils/__tests__/request-call-recording-summary-generation.test.tsindex a79ebf08f84..288a0d39c6c 100644--- a/packages/twenty-apps/public/call-recorder/src/front-components/utils/__tests__/request-call-recording-summary-generation.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/front-components/utils/__tests__/request-call-recording-summary-generation.test.ts@@ -1,26 +1,26 @@-import { beforeEach, describe, expect, it, vi } from 'vitest';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';import { GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH } from 'src/constants/generate-call-recording-summaries-route-path';import { requestCallRecordingSummaryGeneration } from 'src/front-components/utils/request-call-recording-summary-generation.util';const enqueueSnackbarMock = vi.hoisted(() => vi.fn());const postMock = vi.hoisted(() => vi.fn());+const restApiClientMock = vi.hoisted(() => vi.fn());vi.mock('twenty-sdk/front-component', () => ({enqueueSnackbar: enqueueSnackbarMock,}));vi.mock('twenty-client-sdk/rest', () => ({- RestApiClient: vi.fn(function RestApiClient() {- return {- post: postMock,- };- }),+ RestApiClient: restApiClientMock,}));describe('requestCallRecordingSummaryGeneration', () => {beforeEach(() => {vi.clearAllMocks();+ restApiClientMock.mockImplementation(function RestApiClient() {+ return { post: postMock };+ });postMock.mockResolvedValue({outcome: 'processed',generatedCallRecordingIds: ['call-recording-1'],@@ -29,6 +29,26 @@ describe('requestCallRecordingSummaryGeneration', () => {});});+ afterEach(() => {+ vi.unstubAllEnvs();+ });++ it('posts to the injected functions origin without the legacy prefix', async () => {+ vi.stubEnv('TWENTY_FUNCTIONS_URL', 'https://acme.functions.example.com');++ await requestCallRecordingSummaryGeneration({+ calendarEventIds: ['calendar-event-1'],+ });++ expect(restApiClientMock).toHaveBeenCalledWith({+ baseUrl: 'https://acme.functions.example.com',+ });+ expect(postMock).toHaveBeenCalledWith(+ GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH,+ { calendarEventIds: ['calendar-event-1'] },+ );+ });+it('does nothing when no calendar events are selected', async () => {await requestCallRecordingSummaryGeneration({ calendarEventIds: [] });diff --git a/packages/twenty-apps/public/call-recorder/src/front-components/utils/request-call-recording-summary-generation.util.ts b/packages/twenty-apps/public/call-recorder/src/front-components/utils/request-call-recording-summary-generation.util.tsindex 03ac72909de..5a2f68488db 100644--- a/packages/twenty-apps/public/call-recorder/src/front-components/utils/request-call-recording-summary-generation.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/front-components/utils/request-call-recording-summary-generation.util.ts@@ -1,7 +1,9 @@+import { isNonEmptyString } from '@sniptt/guards';import { RestApiClient } from 'twenty-client-sdk/rest';import { enqueueSnackbar } from 'twenty-sdk/front-component';import { GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH } from 'src/constants/generate-call-recording-summaries-route-path';+import { TWENTY_FUNCTIONS_URL_ENV_VAR_NAME } from 'src/constants/twenty-functions-url-env-var-name';type GenerateSummariesResponse = {outcome?: string;@@ -64,10 +66,17 @@ export const requestCallRecordingSummaryGeneration = async ({}try {- const client = new RestApiClient();+ // The host injects the isolated functions origin; the legacy /s route+ // 410s post-cutoff functions and only remains for self-hosting.+ const functionsBaseUrl = process.env[TWENTY_FUNCTIONS_URL_ENV_VAR_NAME];+ const client = isNonEmptyString(functionsBaseUrl)+ ? new RestApiClient({ baseUrl: functionsBaseUrl })+ : new RestApiClient();const response = await client.post<GenerateSummariesResponse>(- `/s${GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH}`,+ isNonEmptyString(functionsBaseUrl)+ ? GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH+ : `/s${GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH}`,{ calendarEventIds },);diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/reconcile-upcoming-calendar-events.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/reconcile-upcoming-calendar-events.test.tsnew file mode 100644index 00000000000..3510a9a56a5--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/reconcile-upcoming-calendar-events.test.ts@@ -0,0 +1,137 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';+import { type RoutePayload } from 'twenty-sdk/define';++import routeLogicFunction, {+ reconcileUpcomingCalendarEventsHandler,+} from 'src/logic-functions/reconcile-upcoming-calendar-events';++const fetchUpcomingCalendarEventIdsMock = vi.hoisted(() => vi.fn());+const reconcileUpcomingCalendarEventBatchesMock = vi.hoisted(() => vi.fn());++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: vi.fn(),+}));++vi.mock(+ 'src/logic-functions/data/fetch-upcoming-calendar-event-ids.util',+ () => ({+ fetchUpcomingCalendarEventIds: fetchUpcomingCalendarEventIdsMock,+ }),+);++vi.mock(+ 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util',+ () => ({+ reconcileUpcomingCalendarEventBatches:+ reconcileUpcomingCalendarEventBatchesMock,+ }),+);++const buildRoutePayload = (+ body: object | null,+): RoutePayload<{ calendarEventIds?: string[] }> =>+ ({+ body,+ headers: {},+ queryStringParameters: {},+ pathParameters: {},+ isBase64Encoded: false,+ rawBody: undefined,+ requestContext: { http: { method: 'POST', path: '/' } },+ userWorkspaceId: null,+ }) as never;++const BATCH_RESULT = {+ reconciledCalendarEventIds: ['calendar-event-1'],+ failedCalendarEventIds: [],+ remainingCalendarEventIds: [],+ actionCounts: { created: 1, updated: 0, canceled: 0, skipped: 0, failed: 0 },+ continuationRequested: false,+};++describe('reconcileUpcomingCalendarEventsHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ fetchUpcomingCalendarEventIdsMock.mockResolvedValue([]);+ reconcileUpcomingCalendarEventBatchesMock.mockResolvedValue(BATCH_RESULT);+ });++ it('is configured as an authenticated route with a self-invokable timeout', () => {+ expect(routeLogicFunction.config).toEqual(+ expect.objectContaining({+ name: 'reconcile-upcoming-calendar-events',+ timeoutSeconds: 900,+ httpRouteTriggerSettings: {+ path: '/call-recorder/reconcile-upcoming-calendar-events',+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ }),+ );+ });++ it('processes explicit calendar event ids without sweeping', async () => {+ const result = await reconcileUpcomingCalendarEventsHandler(+ buildRoutePayload({ calendarEventIds: ['calendar-event-1'] }),+ );++ expect(result).toEqual({ outcome: 'processed', ...BATCH_RESULT });+ expect(reconcileUpcomingCalendarEventBatchesMock).toHaveBeenCalledWith(+ expect.objectContaining({ calendarEventIds: ['calendar-event-1'] }),+ );+ expect(fetchUpcomingCalendarEventIdsMock).not.toHaveBeenCalled();+ });++ it('sweeps upcoming calendar events when no ids are given', async () => {+ fetchUpcomingCalendarEventIdsMock.mockResolvedValue([+ 'calendar-event-1',+ 'calendar-event-2',+ ]);++ const result = await reconcileUpcomingCalendarEventsHandler(+ buildRoutePayload(null),+ );++ expect(fetchUpcomingCalendarEventIdsMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.any(Date),+ );+ expect(reconcileUpcomingCalendarEventBatchesMock).toHaveBeenCalledWith(+ expect.objectContaining({+ calendarEventIds: ['calendar-event-1', 'calendar-event-2'],+ }),+ );+ expect(result).toEqual({ outcome: 'processed', ...BATCH_RESULT });+ });++ it('short-circuits an empty sweep without running batches', async () => {+ const result = await reconcileUpcomingCalendarEventsHandler(+ buildRoutePayload({}),+ );++ expect(result).toEqual({ outcome: 'nothing-to-reconcile' });+ expect(reconcileUpcomingCalendarEventBatchesMock).not.toHaveBeenCalled();+ });++ it('does not sweep when an empty calendar event selection is sent', async () => {+ const result = await reconcileUpcomingCalendarEventsHandler(+ buildRoutePayload({ calendarEventIds: [] }),+ );++ expect(result).toEqual({ outcome: 'nothing-selected' });+ expect(fetchUpcomingCalendarEventIdsMock).not.toHaveBeenCalled();+ expect(reconcileUpcomingCalendarEventBatchesMock).not.toHaveBeenCalled();+ });++ it('passes a deadline that reserves time for the continuation request', async () => {+ await reconcileUpcomingCalendarEventsHandler(+ buildRoutePayload({ calendarEventIds: ['calendar-event-1'] }),+ );++ const { deadlineAtMs } =+ reconcileUpcomingCalendarEventBatchesMock.mock.calls[0][0];++ expect(deadlineAtMs).toBeLessThan(Date.now() + 900 * 1000);+ expect(deadlineAtMs).toBeGreaterThan(Date.now() + 800 * 1000);+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/start-call-recording-summary-backfill-on-install.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/start-call-recording-summary-backfill-on-install.test.tsdeleted file mode 100644index 791b95f387a..00000000000--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/start-call-recording-summary-backfill-on-install.test.ts+++ /dev/null@@ -1,62 +0,0 @@-import { beforeEach, describe, expect, it, vi } from 'vitest';--import postInstallLogicFunction, {- startCallRecordingSummaryBackfillOnInstallHandler,-} from 'src/logic-functions/start-call-recording-summary-backfill-on-install';--const requestCallRecordingSummariesBackfillMock = vi.hoisted(() => vi.fn());--vi.mock(- 'src/logic-functions/data/request-call-recording-summaries-backfill.util',- () => ({- requestCallRecordingSummariesBackfill:- requestCallRecordingSummariesBackfillMock,- }),-);--describe('start-call-recording-summary-backfill-on-install', () => {- beforeEach(() => {- vi.clearAllMocks();- requestCallRecordingSummariesBackfillMock.mockResolvedValue(true);- });-- it('is configured to run on app version upgrades', () => {- expect(postInstallLogicFunction.config).toEqual(- expect.objectContaining({- name: 'start-call-recording-summary-backfill-on-install',- timeoutSeconds: 30,- shouldRunOnVersionUpgrade: true,- }),- );- });-- it('skips fresh installs', async () => {- const result = await startCallRecordingSummaryBackfillOnInstallHandler({- newVersion: '1.0.6',- });-- expect(result).toEqual({ outcome: 'skipped-initial-install' });- expect(requestCallRecordingSummariesBackfillMock).not.toHaveBeenCalled();- });-- it('requests backfill on version upgrades', async () => {- const result = await startCallRecordingSummaryBackfillOnInstallHandler({- previousVersion: '1.0.5',- newVersion: '1.0.6',- });-- expect(result).toEqual({ outcome: 'backfill-requested' });- expect(requestCallRecordingSummariesBackfillMock).toHaveBeenCalledTimes(1);- });-- it('reports failed backfill kickoff requests', async () => {- requestCallRecordingSummariesBackfillMock.mockResolvedValue(false);-- const result = await startCallRecordingSummaryBackfillOnInstallHandler({- previousVersion: '1.0.5',- newVersion: '1.0.6',- });-- expect(result).toEqual({ outcome: 'backfill-request-failed' });- });-});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/start-post-install-backfills.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/start-post-install-backfills.test.tsnew file mode 100644index 00000000000..0852d5c3277--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/start-post-install-backfills.test.ts@@ -0,0 +1,102 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import postInstallLogicFunction, {+ startPostInstallBackfillsHandler,+} from 'src/logic-functions/start-post-install-backfills';++const requestCallRecordingSummariesBackfillMock = vi.hoisted(() => vi.fn());+const requestUpcomingCalendarEventsReconciliationMock = vi.hoisted(() =>+ vi.fn(),+);++vi.mock(+ 'src/logic-functions/data/request-call-recording-summaries-backfill.util',+ () => ({+ requestCallRecordingSummariesBackfill:+ requestCallRecordingSummariesBackfillMock,+ }),+);++vi.mock(+ 'src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util',+ () => ({+ requestUpcomingCalendarEventsReconciliation:+ requestUpcomingCalendarEventsReconciliationMock,+ }),+);++describe('start-post-install-backfills', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ requestCallRecordingSummariesBackfillMock.mockResolvedValue(true);+ requestUpcomingCalendarEventsReconciliationMock.mockResolvedValue(true);+ });++ it('is configured to run on app version upgrades', () => {+ expect(postInstallLogicFunction.config).toEqual(+ expect.objectContaining({+ name: 'start-post-install-backfills',+ timeoutSeconds: 30,+ shouldRunOnVersionUpgrade: true,+ }),+ );+ });++ it('seeds the sweep and skips summaries on a fresh install', async () => {+ const result = await startPostInstallBackfillsHandler({+ newVersion: '1.0.7',+ });++ expect(result).toEqual({+ calendarEventSweepOutcome: 'sweep-requested',+ summaryBackfillOutcome: 'skipped-initial-install',+ });+ expect(+ requestUpcomingCalendarEventsReconciliationMock,+ ).toHaveBeenCalledTimes(1);+ expect(requestCallRecordingSummariesBackfillMock).not.toHaveBeenCalled();+ });++ it('backfills summaries and skips the sweep on an upgrade', async () => {+ const result = await startPostInstallBackfillsHandler({+ previousVersion: '1.0.6',+ newVersion: '1.0.7',+ });++ expect(result).toEqual({+ calendarEventSweepOutcome: 'skipped-upgrade',+ summaryBackfillOutcome: 'backfill-requested',+ });+ expect(requestCallRecordingSummariesBackfillMock).toHaveBeenCalledTimes(1);+ expect(+ requestUpcomingCalendarEventsReconciliationMock,+ ).not.toHaveBeenCalled();+ });++ it('throws when the fresh-install sweep kickoff fails', async () => {+ requestUpcomingCalendarEventsReconciliationMock.mockResolvedValue(false);++ await expect(+ startPostInstallBackfillsHandler({ newVersion: '1.0.7' }),+ ).rejects.toThrow(+ 'Failed to start post-install backfills: upcoming calendar event sweep',+ );+ expect(requestCallRecordingSummariesBackfillMock).not.toHaveBeenCalled();+ });++ it('throws when the upgrade summary backfill kickoff fails', async () => {+ requestCallRecordingSummariesBackfillMock.mockResolvedValue(false);++ await expect(+ startPostInstallBackfillsHandler({+ previousVersion: '1.0.6',+ newVersion: '1.0.7',+ }),+ ).rejects.toThrow(+ 'Failed to start post-install backfills: call recording summary backfill',+ );+ expect(+ requestUpcomingCalendarEventsReconciliationMock,+ ).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/sweep-upcoming-calendar-events.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/sweep-upcoming-calendar-events.test.tsnew file mode 100644index 00000000000..234ece8c2fe--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/sweep-upcoming-calendar-events.test.ts@@ -0,0 +1,92 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import sweepLogicFunction, {+ sweepUpcomingCalendarEventsHandler,+} from 'src/logic-functions/sweep-upcoming-calendar-events';++const fetchUpcomingCalendarEventIdsMock = vi.hoisted(() => vi.fn());+const reconcileUpcomingCalendarEventBatchesMock = vi.hoisted(() => vi.fn());++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: vi.fn(),+}));++vi.mock(+ 'src/logic-functions/data/fetch-upcoming-calendar-event-ids.util',+ () => ({+ fetchUpcomingCalendarEventIds: fetchUpcomingCalendarEventIdsMock,+ }),+);++vi.mock(+ 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util',+ () => ({+ reconcileUpcomingCalendarEventBatches:+ reconcileUpcomingCalendarEventBatchesMock,+ }),+);++const BATCH_RESULT = {+ reconciledCalendarEventIds: ['calendar-event-1'],+ failedCalendarEventIds: [],+ remainingCalendarEventIds: [],+ actionCounts: { created: 1, updated: 0, canceled: 0, skipped: 0, failed: 0 },+ continuationRequested: false,+};++describe('sweepUpcomingCalendarEventsHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ fetchUpcomingCalendarEventIdsMock.mockResolvedValue([]);+ reconcileUpcomingCalendarEventBatchesMock.mockResolvedValue(BATCH_RESULT);+ });++ it('is configured as a daily cron with a self-invokable timeout', () => {+ expect(sweepLogicFunction.config).toEqual(+ expect.objectContaining({+ name: 'sweep-upcoming-calendar-events',+ timeoutSeconds: 900,+ cronTriggerSettings: { pattern: '0 4 * * *' },+ }),+ );+ });++ it('reconciles every upcoming calendar event within the horizon', async () => {+ fetchUpcomingCalendarEventIdsMock.mockResolvedValue([+ 'calendar-event-1',+ 'calendar-event-2',+ ]);++ const result = await sweepUpcomingCalendarEventsHandler();++ expect(fetchUpcomingCalendarEventIdsMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.any(Date),+ );+ expect(reconcileUpcomingCalendarEventBatchesMock).toHaveBeenCalledWith(+ expect.objectContaining({+ calendarEventIds: ['calendar-event-1', 'calendar-event-2'],+ }),+ );+ expect(result).toEqual({ outcome: 'processed', ...BATCH_RESULT });+ });++ it('short-circuits without running batches when nothing is upcoming', async () => {+ const result = await sweepUpcomingCalendarEventsHandler();++ expect(result).toEqual({ outcome: 'nothing-to-reconcile' });+ expect(reconcileUpcomingCalendarEventBatchesMock).not.toHaveBeenCalled();+ });++ it('passes a deadline that reserves time for the continuation request', async () => {+ fetchUpcomingCalendarEventIdsMock.mockResolvedValue(['calendar-event-1']);++ await sweepUpcomingCalendarEventsHandler();++ const { deadlineAtMs } =+ reconcileUpcomingCalendarEventBatchesMock.mock.calls[0][0];++ expect(deadlineAtMs).toBeLessThan(Date.now() + 900 * 1000);+ expect(deadlineAtMs).toBeGreaterThan(Date.now() + 800 * 1000);+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-event-reconciliation-batch-size.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-event-reconciliation-batch-size.tsnew file mode 100644index 00000000000..036d5b62b27--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-event-reconciliation-batch-size.ts@@ -0,0 +1 @@+export const UPCOMING_CALENDAR_EVENT_RECONCILIATION_BATCH_SIZE = 25;diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-event-scheduling-horizon-days.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-event-scheduling-horizon-days.tsnew file mode 100644index 00000000000..933e87b93b1--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-event-scheduling-horizon-days.ts@@ -0,0 +1,4 @@+// Recall recommends scheduling bots for a rolling near-term window rather than far in advance,+// so bots carry fresh config and volatile far-future meetings are not scheduled speculatively.+// 7 days matches Recall's "daily sync of the next 7 days" guidance for self-managed calendar integrations.+export const UPCOMING_CALENDAR_EVENT_SCHEDULING_HORIZON_DAYS = 7;diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-events-sweep-cron-pattern.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-events-sweep-cron-pattern.tsnew file mode 100644index 00000000000..a81a8189811--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/upcoming-calendar-events-sweep-cron-pattern.ts@@ -0,0 +1,2 @@+// Daily sweep of the scheduling-horizon window, per Recall's daily-sync guidance.+export const UPCOMING_CALENDAR_EVENTS_SWEEP_CRON_PATTERN = '0 4 * * *';diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/fetch-upcoming-calendar-event-ids.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/fetch-upcoming-calendar-event-ids.test.tsnew file mode 100644index 00000000000..ea4125c0660--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/fetch-upcoming-calendar-event-ids.test.ts@@ -0,0 +1,101 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';+import { CoreApiClient } from 'twenty-client-sdk/core';++import { fetchUpcomingCalendarEventIds } from 'src/logic-functions/data/fetch-upcoming-calendar-event-ids.util';++const queryMock = vi.fn();++const CLIENT: CoreApiClient = Object.assign(+ Object.create(CoreApiClient.prototype),+ {+ query: queryMock,+ mutation: vi.fn(),+ },+);++const NOW = new Date('2026-07-04T12:00:00.000Z');++const buildPage = (+ calendarEventIds: string[],+ { hasNextPage = false, endCursor = null as string | null } = {},+) => ({+ calendarEvents: {+ pageInfo: { hasNextPage, endCursor },+ edges: calendarEventIds.map((calendarEventId) => ({+ node: { id: calendarEventId },+ })),+ },+});++describe('fetchUpcomingCalendarEventIds', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ it('filters to non-canceled events starting within the scheduling horizon and not yet ended, closest first', async () => {+ queryMock.mockResolvedValue(buildPage(['calendar-event-1']));++ await fetchUpcomingCalendarEventIds(CLIENT, NOW);++ expect(queryMock).toHaveBeenCalledWith(+ expect.objectContaining({+ calendarEvents: expect.objectContaining({+ __args: expect.objectContaining({+ filter: {+ isCanceled: { eq: false },+ or: [+ {+ and: [+ { startsAt: { lte: '2026-07-11T12:00:00.000Z' } },+ { endsAt: { gt: '2026-07-04T12:00:00.000Z' } },+ ],+ },+ {+ and: [+ { endsAt: { is: 'NULL' } },+ { startsAt: { gt: '2026-07-04T12:00:00.000Z' } },+ { startsAt: { lte: '2026-07-11T12:00:00.000Z' } },+ ],+ },+ ],+ },+ orderBy: [{ startsAt: 'AscNullsLast' }],+ }),+ }),+ }),+ );+ });++ it('pages through every result and returns unique sorted ids', async () => {+ queryMock+ .mockResolvedValueOnce(+ buildPage(['calendar-event-2', 'calendar-event-1'], {+ hasNextPage: true,+ endCursor: 'cursor-1',+ }),+ )+ .mockResolvedValueOnce(+ buildPage(['calendar-event-3', 'calendar-event-2']),+ );++ const calendarEventIds = await fetchUpcomingCalendarEventIds(CLIENT, NOW);++ expect(queryMock).toHaveBeenCalledTimes(2);+ expect(queryMock.mock.calls[1][0].calendarEvents.__args.after).toBe(+ 'cursor-1',+ );+ expect(calendarEventIds).toEqual([+ 'calendar-event-1',+ 'calendar-event-2',+ 'calendar-event-3',+ ]);+ });++ it('returns an empty list when no upcoming events exist', async () => {+ queryMock.mockResolvedValue(buildPage([]));++ await expect(fetchUpcomingCalendarEventIds(CLIENT, NOW)).resolves.toEqual(+ [],+ );+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/post-to-own-route.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/post-to-own-route.test.tsnew file mode 100644index 00000000000..c8e93de959b--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/post-to-own-route.test.ts@@ -0,0 +1,75 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { postToOwnRoute } from 'src/logic-functions/data/post-to-own-route.util';++const postMock = vi.hoisted(() => vi.fn());+const restApiClientMock = vi.hoisted(() => vi.fn());+const resolveOwnRouteBaseUrlMock = vi.hoisted(() => vi.fn());++vi.mock('twenty-client-sdk/rest', () => ({+ RestApiClient: restApiClientMock,+}));++vi.mock('src/logic-functions/data/resolve-own-route-base-url.util', () => ({+ resolveOwnRouteBaseUrl: resolveOwnRouteBaseUrlMock,+}));++describe('postToOwnRoute', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ restApiClientMock.mockImplementation(function RestApiClient() {+ return { post: postMock };+ });+ postMock.mockResolvedValue({});+ resolveOwnRouteBaseUrlMock.mockReturnValue(+ 'https://acme.functions.example.com',+ );+ });++ it('posts to the functions origin when resolved', async () => {+ const result = await postToOwnRoute({+ path: '/call-recorder/some-route',+ body: { key: 'value' },+ });++ expect(result).toBe(true);+ expect(restApiClientMock).toHaveBeenCalledWith({+ baseUrl: 'https://acme.functions.example.com',+ });+ expect(postMock).toHaveBeenCalledWith(+ '/call-recorder/some-route',+ { key: 'value' },+ { signal: expect.any(AbortSignal) },+ );+ });++ it('treats timeout as a successfully flushed request', async () => {+ const timeoutError = new Error('Timed out');+ timeoutError.name = 'TimeoutError';+ postMock.mockRejectedValue(timeoutError);++ await expect(+ postToOwnRoute({ path: '/call-recorder/some-route', body: {} }),+ ).resolves.toBe(true);+ });++ it('returns false when the request fails before flushing', async () => {+ postMock.mockRejectedValue(new Error('Network failed'));++ await expect(+ postToOwnRoute({ path: '/call-recorder/some-route', body: {} }),+ ).resolves.toBe(false);+ });++ it('returns false when the route base url cannot be resolved', async () => {+ resolveOwnRouteBaseUrlMock.mockImplementation(() => {+ throw new Error('Unable to resolve target');+ });++ await expect(+ postToOwnRoute({ path: '/call-recorder/some-route', body: {} }),+ ).resolves.toBe(false);+ expect(restApiClientMock).not.toHaveBeenCalled();+ expect(postMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-call-recording-summaries-backfill.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-call-recording-summaries-backfill.test.tsindex 2446bc101e3..b096af371d4 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-call-recording-summaries-backfill.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-call-recording-summaries-backfill.test.ts@@ -3,43 +3,30 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';import { GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH } from 'src/constants/generate-call-recording-summaries-route-path';import { requestCallRecordingSummariesBackfill } from 'src/logic-functions/data/request-call-recording-summaries-backfill.util';-const postMock = vi.hoisted(() => vi.fn());--vi.mock('twenty-client-sdk/rest', () => ({- RestApiClient: vi.fn(function RestApiClient() {- return {- post: postMock,- };- }),+const postToOwnRouteMock = vi.hoisted(() => vi.fn());++vi.mock('src/logic-functions/data/post-to-own-route.util', () => ({+ postToOwnRoute: postToOwnRouteMock,}));describe('requestCallRecordingSummariesBackfill', () => {beforeEach(() => {vi.clearAllMocks();- postMock.mockResolvedValue({});+ postToOwnRouteMock.mockResolvedValue(true);});it('posts an empty body to the summary generation route', async () => {const result = await requestCallRecordingSummariesBackfill();expect(result).toBe(true);- expect(postMock).toHaveBeenCalledWith(- `/s${GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH}`,- {},- { signal: expect.any(AbortSignal) },- );- });-- it('treats timeout as a successfully flushed request', async () => {- const timeoutError = new Error('Timed out');- timeoutError.name = 'TimeoutError';- postMock.mockRejectedValue(timeoutError);-- await expect(requestCallRecordingSummariesBackfill()).resolves.toBe(true);+ expect(postToOwnRouteMock).toHaveBeenCalledWith({+ path: GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH,+ body: {},+ });});- it('returns false when the kickoff request fails before flushing', async () => {- postMock.mockRejectedValue(new Error('Network failed'));+ it('reports a kickoff that failed to fire', async () => {+ postToOwnRouteMock.mockResolvedValue(false);await expect(requestCallRecordingSummariesBackfill()).resolves.toBe(false);});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-upcoming-calendar-events-reconciliation.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-upcoming-calendar-events-reconciliation.test.tsnew file mode 100644index 00000000000..78da918dfe6--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/request-upcoming-calendar-events-reconciliation.test.ts@@ -0,0 +1,46 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH } from 'src/constants/reconcile-upcoming-calendar-events-route-path';+import { requestUpcomingCalendarEventsReconciliation } from 'src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util';++const postToOwnRouteMock = vi.hoisted(() => vi.fn());++vi.mock('src/logic-functions/data/post-to-own-route.util', () => ({+ postToOwnRoute: postToOwnRouteMock,+}));++describe('requestUpcomingCalendarEventsReconciliation', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ postToOwnRouteMock.mockResolvedValue(true);+ });++ it('posts an empty body to start a full sweep', async () => {+ const result = await requestUpcomingCalendarEventsReconciliation();++ expect(result).toBe(true);+ expect(postToOwnRouteMock).toHaveBeenCalledWith({+ path: RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH,+ body: {},+ });+ });++ it('posts the remaining calendar event ids to continue a sweep', async () => {+ await requestUpcomingCalendarEventsReconciliation({+ calendarEventIds: ['calendar-event-1', 'calendar-event-2'],+ });++ expect(postToOwnRouteMock).toHaveBeenCalledWith({+ path: RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH,+ body: { calendarEventIds: ['calendar-event-1', 'calendar-event-2'] },+ });+ });++ it('reports a kickoff that failed to fire', async () => {+ postToOwnRouteMock.mockResolvedValue(false);++ await expect(requestUpcomingCalendarEventsReconciliation()).resolves.toBe(+ false,+ );+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/resolve-own-route-base-url.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/resolve-own-route-base-url.test.tsnew file mode 100644index 00000000000..4d5761e133c--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/__tests__/resolve-own-route-base-url.test.ts@@ -0,0 +1,23 @@+import { afterEach, describe, expect, it, vi } from 'vitest';++import { resolveOwnRouteBaseUrl } from 'src/logic-functions/data/resolve-own-route-base-url.util';++describe('resolveOwnRouteBaseUrl', () => {+ afterEach(() => {+ vi.unstubAllEnvs();+ });++ it('returns the injected functions url', () => {+ vi.stubEnv('TWENTY_FUNCTIONS_URL', 'https://acme.functions.example.com');++ expect(resolveOwnRouteBaseUrl()).toBe('https://acme.functions.example.com');+ });++ it('fails clearly when the functions url is not injected', () => {+ vi.stubEnv('TWENTY_FUNCTIONS_URL', '');++ expect(() => resolveOwnRouteBaseUrl()).toThrow(+ 'Unable to resolve Call Recorder own route target without TWENTY_FUNCTIONS_URL',+ );+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/create-call-recording.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/create-call-recording.util.tsindex c8ed9a95f5b..208361c7ea7 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/create-call-recording.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/create-call-recording.util.ts@@ -5,7 +5,7 @@ import { type CallRecordingRequestStatus } from 'src/logic-functions/constants/cimport { type CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';export type ScheduledCallRecordingFields = {- title: string | null;+ title: string;status: CallRecordingStatus.SCHEDULED;recordingRequestStatus: CallRecordingRequestStatus.REQUESTED;calendarEventId: string;diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/fetch-upcoming-calendar-event-ids.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/fetch-upcoming-calendar-event-ids.util.tsnew file mode 100644index 00000000000..2b9f9aa91ee--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/fetch-upcoming-calendar-event-ids.util.ts@@ -0,0 +1,75 @@+import { 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 {+ fetchAllNodes,+ type ConnectionPage,+} from 'src/logic-functions/data/fetch-all-nodes.util';+import { computeUpcomingCalendarEventHorizonEnd } from 'src/logic-functions/domain/compute-upcoming-calendar-event-horizon-end.util';+import { getUniqueSortedIds } from 'src/logic-functions/utils/get-unique-sorted-ids.util';++type CalendarEventIdNode = {+ id: string;+};++export const fetchUpcomingCalendarEventIds = async (+ client: CoreApiClient,+ now: Date,+): Promise<string[]> => {+ const nowIsoString = now.toISOString();+ const horizonEndIsoString =+ computeUpcomingCalendarEventHorizonEnd(now).toISOString();++ const calendarEventNodes = await fetchAllNodes<CalendarEventIdNode>(+ async (afterCursor) => {+ const queryResult = await client.query({+ calendarEvents: {+ __args: {+ filter: {+ isCanceled: { eq: false },+ // Mirror the policy: the horizon is measured from startsAt (the bot's join time),+ // while endsAt drives the not-past check so in-progress meetings still qualify.+ // Ranges use and-ed entries because the API applies one operator per field filter.+ or: [+ {+ and: [+ { startsAt: { lte: horizonEndIsoString } },+ { endsAt: { gt: nowIsoString } },+ ],+ },+ {+ and: [+ { endsAt: { is: 'NULL' } },+ { startsAt: { gt: nowIsoString } },+ { startsAt: { lte: horizonEndIsoString } },+ ],+ },+ ],+ },+ orderBy: [{ startsAt: 'AscNullsLast' }],+ first: TWENTY_PAGE_SIZE,+ ...(isUndefined(afterCursor) ? {} : { after: afterCursor }),+ },+ pageInfo: {+ hasNextPage: true,+ endCursor: true,+ },+ edges: {+ node: {+ id: true,+ },+ },+ },+ });++ return queryResult.calendarEvents as+ | ConnectionPage<CalendarEventIdNode>+ | undefined;+ },+ );++ return getUniqueSortedIds(+ calendarEventNodes.map((calendarEvent) => calendarEvent.id),+ );+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/post-to-own-route.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/post-to-own-route.util.tsnew file mode 100644index 00000000000..9445f41a22e--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/post-to-own-route.util.ts@@ -0,0 +1,40 @@+import { RestApiClient } from 'twenty-client-sdk/rest';++import { resolveOwnRouteBaseUrl } from 'src/logic-functions/data/resolve-own-route-base-url.util';++const OWN_ROUTE_FLUSH_MS = 5_000;++// Fire-and-forget POST to one of this app's own HTTP routes; a timeout only+// means the request was flushed, not that the target run failed.+export const postToOwnRoute = async ({+ path,+ body,+}: {+ path: string;+ body: object;+}): Promise<boolean> => {+ try {+ const client = new RestApiClient({ baseUrl: resolveOwnRouteBaseUrl() });++ await client.post(path, body, {+ signal: AbortSignal.timeout(OWN_ROUTE_FLUSH_MS),+ });++ return true;+ } catch (error) {+ if (+ error instanceof Error &&+ (error.name === 'TimeoutError' || error.name === 'AbortError')+ ) {+ return true;+ }++ if (process.env.NODE_ENV !== 'test') {+ console.error(+ `[call-recorder] request to own route ${path} failed to fire: ${error instanceof Error ? error.message : String(error)}`,+ );+ }++ return false;+ }+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-backfill.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-backfill.util.tsindex 15a2e4b669b..27b5f42faf5 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-backfill.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-backfill.util.ts@@ -1,35 +1,8 @@-import { RestApiClient } from 'twenty-client-sdk/rest';-import { GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH } from 'src/constants/generate-call-recording-summaries-route-path';+import { postToOwnRoute } from 'src/logic-functions/data/post-to-own-route.util';-const BACKFILL_KICKOFF_FLUSH_MS = 5_000;--export const requestCallRecordingSummariesBackfill =- async (): Promise<boolean> => {- const client = new RestApiClient();-- try {- await client.post(- `/s${GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH}`,- {},- { signal: AbortSignal.timeout(BACKFILL_KICKOFF_FLUSH_MS) },- );-- return true;- } catch (error) {- if (- error instanceof Error &&- (error.name === 'TimeoutError' || error.name === 'AbortError')- ) {- return true;- }-- if (process.env.NODE_ENV !== 'test') {- console.error(- `[call-recorder] summary backfill kickoff failed to fire: ${error instanceof Error ? error.message : String(error)}`,- );- }-- return false;- }- };+export const requestCallRecordingSummariesBackfill = async (): Promise<boolean> =>+ postToOwnRoute({+ path: GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH,+ body: {},+ });diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-continuation.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-continuation.util.tsindex 17787ca4160..93043b6d5e9 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-continuation.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-call-recording-summaries-continuation.util.ts@@ -1,38 +1,12 @@-import { RestApiClient } from 'twenty-client-sdk/rest';-import { GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH } from 'src/constants/generate-call-recording-summaries-route-path';--const CONTINUATION_FLUSH_MS = 5_000;+import { postToOwnRoute } from 'src/logic-functions/data/post-to-own-route.util';export const requestCallRecordingSummariesContinuation = async ({callRecordingIds,}: {callRecordingIds: string[];-}): Promise<boolean> => {- const client = new RestApiClient();-- try {- await client.post(- `/s${GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH}`,- { callRecordingIds },- { signal: AbortSignal.timeout(CONTINUATION_FLUSH_MS) },- );-- return true;- } catch (error) {- if (- error instanceof Error &&- (error.name === 'TimeoutError' || error.name === 'AbortError')- ) {- return true;- }-- if (process.env.NODE_ENV !== 'test') {- console.error(- `[call-recorder] summary generation continuation failed to fire: ${error instanceof Error ? error.message : String(error)}`,- );- }-- return false;- }-};+}): Promise<boolean> =>+ postToOwnRoute({+ path: GENERATE_CALL_RECORDING_SUMMARIES_ROUTE_PATH,+ body: { callRecordingIds },+ });diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util.tsnew file mode 100644index 00000000000..68ee3895416--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util.ts@@ -0,0 +1,14 @@+import { isUndefined } from '@sniptt/guards';++import { RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH } from 'src/constants/reconcile-upcoming-calendar-events-route-path';+import { postToOwnRoute } from 'src/logic-functions/data/post-to-own-route.util';++export const requestUpcomingCalendarEventsReconciliation = async ({+ calendarEventIds,+}: {+ calendarEventIds?: string[];+} = {}): Promise<boolean> =>+ postToOwnRoute({+ path: RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH,+ body: isUndefined(calendarEventIds) ? {} : { calendarEventIds },+ });diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/resolve-own-route-base-url.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/resolve-own-route-base-url.util.tsnew file mode 100644index 00000000000..d8491ccf3df--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/resolve-own-route-base-url.util.ts@@ -0,0 +1,14 @@+import { TWENTY_FUNCTIONS_URL_ENV_VAR_NAME } from 'src/constants/twenty-functions-url-env-var-name';+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';++export const resolveOwnRouteBaseUrl = (): string => {+ const injectedFunctionsUrl = process.env[TWENTY_FUNCTIONS_URL_ENV_VAR_NAME];++ if (!isNonEmptyString(injectedFunctionsUrl)) {+ throw new Error(+ `Unable to resolve Call Recorder own route target without ${TWENTY_FUNCTIONS_URL_ENV_VAR_NAME}`,+ );+ }++ return injectedFunctionsUrl;+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recorder-policy-result.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recorder-policy-result.test.tsindex 3fc2679cf86..b7ad56cbf39 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recorder-policy-result.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recorder-policy-result.test.ts@@ -8,6 +8,9 @@ const FUTURE_STARTS_AT = '2026-01-01T13:00:00.000Z';const FUTURE_ENDS_AT = '2026-01-01T14:00:00.000Z';const PAST_STARTS_AT = '2026-01-01T09:00:00.000Z';const PAST_ENDS_AT = '2026-01-01T10:00:00.000Z';+// The scheduling horizon is 7 days, so these fall beyond it.+const BEYOND_HORIZON_STARTS_AT = '2026-01-10T13:00:00.000Z';+const BEYOND_HORIZON_ENDS_AT = '2026-01-10T14:00:00.000Z';describe('resolveCallRecorderPolicyResult', () => {it('requires a bot when preference is ON and the event is upcoming', () => {@@ -117,4 +120,58 @@ describe('resolveCallRecorderPolicyResult', () => {reason: 'EVENT_CANCELED',});});++ it('does not request a bot for an event beyond the scheduling horizon', () => {+ expect(+ resolveCallRecorderPolicyResult({+ input: {+ callRecorderPreference: CallRecorderPreference.ON,+ isCanceled: false,+ startsAt: BEYOND_HORIZON_STARTS_AT,+ endsAt: BEYOND_HORIZON_ENDS_AT,+ conferenceLinkUrl: 'https://meet.example.com/team-sync',+ },+ now: NOW,+ }),+ ).toEqual({+ shouldRequestBot: false,+ reason: 'EVENT_BEYOND_SCHEDULING_HORIZON',+ });+ });++ it('requires a bot for a long meeting that starts within the horizon but ends beyond it', () => {+ expect(+ resolveCallRecorderPolicyResult({+ input: {+ callRecorderPreference: CallRecorderPreference.ON,+ isCanceled: false,+ startsAt: FUTURE_STARTS_AT,+ endsAt: BEYOND_HORIZON_ENDS_AT,+ conferenceLinkUrl: 'https://meet.example.com/team-sync',+ },+ now: NOW,+ }),+ ).toEqual({+ shouldRequestBot: true,+ reason: 'RECORDING_ENABLED',+ });+ });++ it('falls back to endsAt for the horizon when startsAt is an empty string', () => {+ expect(+ resolveCallRecorderPolicyResult({+ input: {+ callRecorderPreference: CallRecorderPreference.ON,+ isCanceled: false,+ startsAt: '',+ endsAt: FUTURE_ENDS_AT,+ conferenceLinkUrl: 'https://meet.example.com/team-sync',+ },+ now: NOW,+ }),+ ).toEqual({+ shouldRequestBot: true,+ reason: 'RECORDING_ENABLED',+ });+ });});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recording-title.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recording-title.test.tsnew file mode 100644index 00000000000..b5e2cc1dde6--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/__tests__/resolve-call-recording-title.test.ts@@ -0,0 +1,32 @@+import { describe, expect, it } from 'vitest';++import { resolveCallRecordingTitle } from 'src/logic-functions/domain/resolve-call-recording-title.util';++describe('resolveCallRecordingTitle', () => {+ it('uses a visible calendar event title', () => {+ expect(+ resolveCallRecordingTitle({+ title: ' Customer Sync ',+ startsAt: '2026-01-01T13:00:00.000Z',+ }),+ ).toBe('Customer Sync');+ });++ it('falls back to the calendar event start time when the title is unavailable', () => {+ expect(+ resolveCallRecordingTitle({+ title: undefined,+ startsAt: '2026-01-01T13:00:00.000Z',+ }),+ ).toBe('Call recording - Jan 1, 2026, 1:00 PM UTC');+ });++ it('uses a generic fallback when the title and start time are unavailable', () => {+ expect(+ resolveCallRecordingTitle({+ title: undefined,+ startsAt: undefined,+ }),+ ).toBe('Call recording');+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/compute-upcoming-calendar-event-horizon-end.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/compute-upcoming-calendar-event-horizon-end.util.tsnew file mode 100644index 00000000000..dcde409f9c6--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/compute-upcoming-calendar-event-horizon-end.util.ts@@ -0,0 +1,11 @@+import { UPCOMING_CALENDAR_EVENT_SCHEDULING_HORIZON_DAYS } from 'src/logic-functions/constants/upcoming-calendar-event-scheduling-horizon-days';++export const computeUpcomingCalendarEventHorizonEnd = (now: Date): Date => {+ const horizonEnd = new Date(now);++ horizonEnd.setDate(+ horizonEnd.getDate() + UPCOMING_CALENDAR_EVENT_SCHEDULING_HORIZON_DAYS,+ );++ return horizonEnd;+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recorder-policy-result.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recorder-policy-result.util.tsindex 46ca58b5d20..a2899c35b23 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recorder-policy-result.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recorder-policy-result.util.ts@@ -1,4 +1,7 @@+import { isUndefined } from '@sniptt/guards';+import { CallRecorderPreference } from 'src/constants/call-recorder-preference';+import { computeUpcomingCalendarEventHorizonEnd } from 'src/logic-functions/domain/compute-upcoming-calendar-event-horizon-end.util';import { type CallRecorderPolicyInput } from 'src/logic-functions/types/call-recorder-policy-input.type';import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';import { type CallRecorderPolicyNotRequiredReason } from 'src/logic-functions/types/call-recorder-policy-not-required-reason.type';@@ -36,31 +39,65 @@ export const resolveCallRecorderPolicyResult = ({return botNotRequired('EVENT_NOT_UPCOMING');}+ if (+ !isCalendarEventWithinSchedulingHorizon({+ startsAt: input.startsAt,+ endsAt: input.endsAt,+ now,+ })+ ) {+ return botNotRequired('EVENT_BEYOND_SCHEDULING_HORIZON');+ }+return botRequired('RECORDING_ENABLED');};+type CalendarEventWindowInput = {+ startsAt: string | undefined;+ endsAt: string | undefined;+ now: Date;+};++const parseTimestampMs = (+ timestamp: string | undefined,+): number | undefined => {+ if (!isNonEmptyString(timestamp)) {+ return undefined;+ }++ const timestampMs = new Date(timestamp).getTime();++ return Number.isNaN(timestampMs) ? undefined : timestampMs;+};+const isCalendarEventInFuture = ({startsAt,endsAt,now,-}: {- startsAt: string | undefined;- endsAt: string | undefined;- now: Date;-}): boolean => {- const reference = endsAt ?? startsAt;+}: CalendarEventWindowInput): boolean => {+ const referenceMs = parseTimestampMs(endsAt) ?? parseTimestampMs(startsAt);- if (!isNonEmptyString(reference)) {+ if (isUndefined(referenceMs)) {return false;}- const referenceTime = new Date(reference).getTime();+ return referenceMs > now.getTime();+};++// The bot joins at the meeting start, so the horizon is measured from startsAt+// (endsAt only as a fallback), unlike the not-past check which measures from the end.+const isCalendarEventWithinSchedulingHorizon = ({+ startsAt,+ endsAt,+ now,+}: CalendarEventWindowInput): boolean => {+ const referenceMs = parseTimestampMs(startsAt) ?? parseTimestampMs(endsAt);- if (Number.isNaN(referenceTime)) {+ if (isUndefined(referenceMs)) {return false;}- return referenceTime > now.getTime();+ return referenceMs <= computeUpcomingCalendarEventHorizonEnd(now).getTime();};const botRequired = (diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recording-title.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recording-title.util.tsnew file mode 100644index 00000000000..6707e234bb1--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/resolve-call-recording-title.util.ts@@ -0,0 +1,61 @@+import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';++const CALL_RECORDING_FALLBACK_TITLE = 'Call recording';++const MONTH_LABELS = [+ 'Jan',+ 'Feb',+ 'Mar',+ 'Apr',+ 'May',+ 'Jun',+ 'Jul',+ 'Aug',+ 'Sep',+ 'Oct',+ 'Nov',+ 'Dec',+] as const;++export const resolveCallRecordingTitle = (+ calendarEvent: Pick<CalendarEventRecord, 'startsAt' | 'title'>,+): string => {+ if (isNonEmptyString(calendarEvent.title)) {+ return calendarEvent.title.trim();+ }++ const formattedCalendarEventStartDateTime =+ formatCalendarEventStartDateTimeForFallbackTitle(calendarEvent.startsAt);++ return isNonEmptyString(formattedCalendarEventStartDateTime)+ ? `${CALL_RECORDING_FALLBACK_TITLE} - ${formattedCalendarEventStartDateTime}`+ : CALL_RECORDING_FALLBACK_TITLE;+};++const formatCalendarEventStartDateTimeForFallbackTitle = (+ calendarEventStartsAt: string | undefined,+): string | undefined => {+ if (!isNonEmptyString(calendarEventStartsAt)) {+ return undefined;+ }++ const calendarEventStartDate = new Date(calendarEventStartsAt);++ if (Number.isNaN(calendarEventStartDate.getTime())) {+ return undefined;+ }++ const monthLabel = MONTH_LABELS[calendarEventStartDate.getUTCMonth()];+ const dayOfMonth = calendarEventStartDate.getUTCDate();+ const year = calendarEventStartDate.getUTCFullYear();+ const hourOfDay = calendarEventStartDate.getUTCHours();+ const hourWithinHalfDay = hourOfDay % 12 === 0 ? 12 : hourOfDay % 12;+ const minuteLabel = calendarEventStartDate+ .getUTCMinutes()+ .toString()+ .padStart(2, '0');+ const meridiemLabel = hourOfDay < 12 ? 'AM' : 'PM';++ return `${monthLabel} ${dayOfMonth}, ${year}, ${hourWithinHalfDay}:${minuteLabel} ${meridiemLabel} UTC`;+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.tsindex 60b4e5f99a4..fb6e7f65e57 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.ts@@ -269,6 +269,32 @@ describe('reconcileCallRecorderForCalendarEventIds', () => {});});+ it('creates a scheduled call recording with a fallback title when the calendar title is unavailable', async () => {+ const client = buildFakeCoreApiClient({+ calendarEvents: [buildCalendarEvent({ title: undefined })],+ });++ const result = await reconcileCallRecorderForCalendarEventIds({+ client: client as unknown as CoreApiClient,+ calendarEventIds: ['calendar-event-1'],+ now: NOW,+ });++ expect(result).toEqual([+ expect.objectContaining({+ action: 'CREATED',+ callRecordingId: buildCustomerSyncCallRecordingId(),+ }),+ ]);+ expect(client.callRecordings).toEqual([+ expect.objectContaining({+ title: 'Call recording - Jan 1, 2026, 1:00 PM UTC',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ }),+ ]);+ });+it('creates a scheduled call recording for the default ON preference', async () => {const client = buildFakeCoreApiClient({calendarEvents: [buildCalendarEvent({ callRecorderPreference: null })],@@ -417,6 +443,44 @@ describe('reconcileCallRecorderForCalendarEventIds', () => {});});+ it('replaces a stale visible title with the fallback title when the calendar title becomes unavailable', async () => {+ const client = buildFakeCoreApiClient({+ calendarEvents: [buildCalendarEvent({ title: undefined })],+ callRecordings: [+ {+ id: buildCustomerSyncCallRecordingId(),+ title: 'Old Customer Sync',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ startedAt: FUTURE_STARTS_AT,+ endedAt: FUTURE_ENDS_AT,+ calendarEventId: 'calendar-event-1',+ externalBotId: 'recall-bot-1',+ },+ ],+ });++ const result = await reconcileCallRecorderForCalendarEventIds({+ client: client as unknown as CoreApiClient,+ calendarEventIds: ['calendar-event-1'],+ now: NOW,+ });++ expect(result).toEqual([+ expect.objectContaining({+ action: 'UPDATED',+ callRecordingId: buildCustomerSyncCallRecordingId(),+ }),+ ]);+ expect(client.callRecordings).toEqual([+ expect.objectContaining({+ title: 'Call recording - Jan 1, 2026, 1:00 PM UTC',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ }),+ ]);+ });+it('cancels an existing scheduled request when the policy no longer requests a bot', async () => {const client = buildFakeCoreApiClient({calendarEvents: [diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-upcoming-calendar-event-batches.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-upcoming-calendar-event-batches.test.tsnew file mode 100644index 00000000000..baabaad78ea--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-upcoming-calendar-event-batches.test.ts@@ -0,0 +1,189 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';+import { CoreApiClient } from 'twenty-client-sdk/core';++import { reconcileUpcomingCalendarEventBatches } from 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util';++const reconcileCallRecorderForCalendarEventIdsMock = vi.hoisted(() => vi.fn());+const requestUpcomingCalendarEventsReconciliationMock = vi.hoisted(() =>+ vi.fn(),+);++vi.mock('src/logic-functions/flows/reconcile-call-recorder.util', () => ({+ reconcileCallRecorderForCalendarEventIds:+ reconcileCallRecorderForCalendarEventIdsMock,+}));++vi.mock(+ 'src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util',+ () => ({+ requestUpcomingCalendarEventsReconciliation:+ requestUpcomingCalendarEventsReconciliationMock,+ }),+);++const CLIENT: CoreApiClient = Object.assign(+ Object.create(CoreApiClient.prototype),+ {+ mutation: vi.fn(),+ query: vi.fn(),+ },+);++const buildCalendarEventIds = (count: number): string[] =>+ Array.from({ length: count }, (_, index) => `calendar-event-${index + 1}`);++describe('reconcileUpcomingCalendarEventBatches', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ reconcileCallRecorderForCalendarEventIdsMock.mockResolvedValue([+ {+ action: 'CREATED',+ realMeetingKey: 'link:meet.example.com/abc:2026-07-05T10:00:00.000Z',+ callRecordingId: 'call-recording-1',+ },+ ]);+ requestUpcomingCalendarEventsReconciliationMock.mockResolvedValue(true);+ });++ it('reconciles every batch when the deadline is far away', async () => {+ const calendarEventIds = buildCalendarEventIds(30);++ const result = await reconcileUpcomingCalendarEventBatches({+ client: CLIENT,+ calendarEventIds,+ deadlineAtMs: Date.now() + 60_000,+ });++ expect(reconcileCallRecorderForCalendarEventIdsMock).toHaveBeenCalledTimes(+ 2,+ );+ expect(+ reconcileCallRecorderForCalendarEventIdsMock,+ ).toHaveBeenNthCalledWith(1, {+ client: CLIENT,+ calendarEventIds: calendarEventIds.slice(0, 25),+ });+ expect(+ reconcileCallRecorderForCalendarEventIdsMock,+ ).toHaveBeenNthCalledWith(2, {+ client: CLIENT,+ calendarEventIds: calendarEventIds.slice(25),+ });+ expect(result.reconciledCalendarEventIds).toEqual(calendarEventIds);+ expect(result.remainingCalendarEventIds).toEqual([]);+ expect(result.actionCounts).toEqual({+ created: 2,+ updated: 0,+ canceled: 0,+ skipped: 0,+ failed: 0,+ });+ expect(result.continuationRequested).toBe(false);+ expect(+ requestUpcomingCalendarEventsReconciliationMock,+ ).not.toHaveBeenCalled();+ });++ it('stops at the deadline and requests a continuation with the remaining ids', async () => {+ const calendarEventIds = buildCalendarEventIds(30);+ // Clock advances 5s per reading: after one batch, 15s + 5s overshoots the deadline.+ let nowMs = 0;+ const getNowMs = () => {+ nowMs += 5_000;++ return nowMs;+ };++ const result = await reconcileUpcomingCalendarEventBatches({+ client: CLIENT,+ calendarEventIds,+ deadlineAtMs: 15_000,+ getNowMs,+ });++ expect(reconcileCallRecorderForCalendarEventIdsMock).toHaveBeenCalledTimes(+ 1,+ );+ expect(result.reconciledCalendarEventIds).toEqual(+ calendarEventIds.slice(0, 25),+ );+ expect(result.remainingCalendarEventIds).toEqual(+ calendarEventIds.slice(25),+ );+ expect(result.continuationRequested).toBe(true);+ expect(+ requestUpcomingCalendarEventsReconciliationMock,+ ).toHaveBeenCalledWith({+ calendarEventIds: calendarEventIds.slice(25),+ });+ });++ it('records a failed batch and keeps processing the next one', async () => {+ const calendarEventIds = buildCalendarEventIds(30);++ reconcileCallRecorderForCalendarEventIdsMock+ .mockRejectedValueOnce(new Error('core api unavailable'))+ .mockResolvedValueOnce([+ {+ action: 'UPDATED',+ realMeetingKey: 'link:meet.example.com/xyz:2026-07-06T10:00:00.000Z',+ callRecordingId: 'call-recording-2',+ },+ ]);++ const result = await reconcileUpcomingCalendarEventBatches({+ client: CLIENT,+ calendarEventIds,+ deadlineAtMs: Date.now() + 60_000,+ });++ expect(result.failedCalendarEventIds).toEqual(calendarEventIds.slice(0, 25));+ expect(result.reconciledCalendarEventIds).toEqual(+ calendarEventIds.slice(25),+ );+ expect(result.remainingCalendarEventIds).toEqual([]);+ expect(result.actionCounts).toEqual({+ created: 0,+ updated: 1,+ canceled: 0,+ skipped: 0,+ failed: 0,+ });+ expect(result.continuationRequested).toBe(false);+ });++ it('tallies every reconciliation action kind', async () => {+ reconcileCallRecorderForCalendarEventIdsMock.mockResolvedValue([+ {+ action: 'CREATED',+ realMeetingKey: 'meeting-1',+ callRecordingId: 'call-recording-1',+ },+ {+ action: 'CANCELED',+ realMeetingKey: 'meeting-2',+ callRecordingId: 'call-recording-2',+ },+ { action: 'SKIPPED', realMeetingKey: 'meeting-3', callRecordingId: null },+ {+ action: 'FAILED',+ realMeetingKey: 'meeting-4',+ errorMessage: 'recall rejected the bot',+ },+ ]);++ const result = await reconcileUpcomingCalendarEventBatches({+ client: CLIENT,+ calendarEventIds: buildCalendarEventIds(4),+ deadlineAtMs: Date.now() + 60_000,+ });++ expect(result.actionCounts).toEqual({+ created: 1,+ updated: 0,+ canceled: 1,+ skipped: 1,+ failed: 1,+ });+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-call-recorder.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-call-recorder.util.tsindex 89c91e98179..9767a6f3a86 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-call-recorder.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-call-recorder.util.ts@@ -23,6 +23,7 @@ import { findCallRecordingsByCalendarEventIds } from 'src/logic-functions/data/fimport { 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 { resolveCallRecordingTitle } from 'src/logic-functions/domain/resolve-call-recording-title.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';@@ -344,15 +345,20 @@ const createPolicyManagedCallRecording = async ({}// Winning the deterministic-id insert elects this run as the single writer that creates the bot.- await ensureCallRecorder(client, {+ const didScheduleBot = await ensureCallRecorder(client, {callRecording: {id: callRecordingId,...scheduledFields,- title: scheduledFields.title ?? undefined,},calendarEvent: representativeCalendarEvent,});+ if (!didScheduleBot && process.env.NODE_ENV !== 'test') {+ console.warn(+ `[call-recorder] created callRecording ${callRecordingId}, but did not schedule a Recall bot`,+ );+ }+return {action: 'CREATED',realMeetingKey,@@ -434,8 +440,7 @@ const reconcileCanceledMeeting = async ({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,+ title: resolveCallRecordingTitle(calendarEvent),recordingRequestStatus: CallRecordingRequestStatus.REQUESTED,calendarEventId: calendarEvent.id,});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-upcoming-calendar-event-batches-result.type.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-upcoming-calendar-event-batches-result.type.tsnew file mode 100644index 00000000000..ff3e60890df--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-upcoming-calendar-event-batches-result.type.ts@@ -0,0 +1,14 @@+import { type CallRecorderReconciliationResult } from 'src/logic-functions/types/call-recorder-reconciliation-result.type';++export type CallRecorderReconciliationActionCounts = Record<+ Lowercase<CallRecorderReconciliationResult['action']>,+ number+>;++export type ReconcileUpcomingCalendarEventBatchesResult = {+ reconciledCalendarEventIds: string[];+ failedCalendarEventIds: string[];+ remainingCalendarEventIds: string[];+ actionCounts: CallRecorderReconciliationActionCounts;+ continuationRequested: boolean;+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util.tsnew file mode 100644index 00000000000..65626dbe420--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util.ts@@ -0,0 +1,100 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { UPCOMING_CALENDAR_EVENT_RECONCILIATION_BATCH_SIZE } from 'src/logic-functions/constants/upcoming-calendar-event-reconciliation-batch-size';+import { requestUpcomingCalendarEventsReconciliation } from 'src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util';+import { reconcileCallRecorderForCalendarEventIds } from 'src/logic-functions/flows/reconcile-call-recorder.util';+import {+ type CallRecorderReconciliationActionCounts,+ type ReconcileUpcomingCalendarEventBatchesResult,+} from 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches-result.type';+import { type CallRecorderReconciliationResult } from 'src/logic-functions/types/call-recorder-reconciliation-result.type';++const ACTION_COUNT_KEY_BY_ACTION: {+ [Action in CallRecorderReconciliationResult['action']]: Lowercase<Action>;+} = {+ CREATED: 'created',+ UPDATED: 'updated',+ CANCELED: 'canceled',+ SKIPPED: 'skipped',+ FAILED: 'failed',+};++export const reconcileUpcomingCalendarEventBatches = async ({+ client,+ calendarEventIds,+ deadlineAtMs,+ getNowMs = () => Date.now(),+}: {+ client: CoreApiClient;+ calendarEventIds: string[];+ deadlineAtMs: number;+ getNowMs?: () => number;+}): Promise<ReconcileUpcomingCalendarEventBatchesResult> => {+ const remainingCalendarEventIds = [...calendarEventIds];+ const reconciledCalendarEventIds: string[] = [];+ const failedCalendarEventIds: string[] = [];+ const actionCounts: CallRecorderReconciliationActionCounts = {+ created: 0,+ updated: 0,+ canceled: 0,+ skipped: 0,+ failed: 0,+ };+ let slowestBatchMs = 0;++ // Process at least one batch per run so the continuation payload strictly shrinks.+ while (remainingCalendarEventIds.length > 0) {+ const batchCalendarEventIds = remainingCalendarEventIds.slice(+ 0,+ UPCOMING_CALENDAR_EVENT_RECONCILIATION_BATCH_SIZE,+ );+ const batchStartedAtMs = getNowMs();++ try {+ const reconciliationResults =+ await reconcileCallRecorderForCalendarEventIds({+ client,+ calendarEventIds: batchCalendarEventIds,+ });++ reconciledCalendarEventIds.push(...batchCalendarEventIds);++ for (const reconciliationResult of reconciliationResults) {+ const actionCountKey =+ ACTION_COUNT_KEY_BY_ACTION[reconciliationResult.action];++ actionCounts[actionCountKey] += 1;+ }+ } catch (error) {+ failedCalendarEventIds.push(...batchCalendarEventIds);++ if (process.env.NODE_ENV !== 'test') {+ console.error(+ `[call-recorder] upcoming calendar event batch reconciliation failed: ${error instanceof Error ? error.message : String(error)}`,+ );+ }+ }++ remainingCalendarEventIds.splice(0, batchCalendarEventIds.length);+ slowestBatchMs = Math.max(slowestBatchMs, getNowMs() - batchStartedAtMs);++ if (getNowMs() + slowestBatchMs > deadlineAtMs) {+ break;+ }+ }++ const continuationRequested =+ remainingCalendarEventIds.length > 0+ ? await requestUpcomingCalendarEventsReconciliation({+ calendarEventIds: remainingCalendarEventIds,+ })+ : false;++ return {+ reconciledCalendarEventIds,+ failedCalendarEventIds,+ remainingCalendarEventIds,+ actionCounts,+ continuationRequested,+ };+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/reconcile-upcoming-calendar-events.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/reconcile-upcoming-calendar-events.tsnew file mode 100644index 00000000000..4b976fdb5ef--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/reconcile-upcoming-calendar-events.ts@@ -0,0 +1,69 @@+import { isUndefined } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';+import { defineLogicFunction, type RoutePayload } from 'twenty-sdk/define';++import { RECONCILE_UPCOMING_CALENDAR_EVENTS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/reconcile-upcoming-calendar-events-logic-function-universal-identifier';+import { RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH } from 'src/constants/reconcile-upcoming-calendar-events-route-path';+import { fetchUpcomingCalendarEventIds } from 'src/logic-functions/data/fetch-upcoming-calendar-event-ids.util';+import { reconcileUpcomingCalendarEventBatches } from 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util';+import { type ReconcileUpcomingCalendarEventBatchesResult } from 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches-result.type';+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';++const TIMEOUT_SECONDS = 900;+const CONTINUATION_RESERVE_MS = 30_000;++type ReconcileUpcomingCalendarEventsRouteBody = {+ calendarEventIds?: unknown;+};++type ReconcileUpcomingCalendarEventsRouteResult =+ | { outcome: 'nothing-selected' }+ | { outcome: 'nothing-to-reconcile' }+ | ({ outcome: 'processed' } & ReconcileUpcomingCalendarEventBatchesResult);++const toIdList = (value: unknown): string[] =>+ Array.isArray(value) ? value.filter(isNonEmptyString) : [];++export const reconcileUpcomingCalendarEventsHandler = async (+ payload: RoutePayload<ReconcileUpcomingCalendarEventsRouteBody>,+): Promise<ReconcileUpcomingCalendarEventsRouteResult> => {+ const startedAtMs = Date.now();+ const client = new CoreApiClient();++ const requestedCalendarEventIds = payload.body?.calendarEventIds;+ const isSweep = isUndefined(requestedCalendarEventIds);++ const calendarEventIds = isSweep+ ? await fetchUpcomingCalendarEventIds(client, new Date(startedAtMs))+ : toIdList(requestedCalendarEventIds);++ if (calendarEventIds.length === 0) {+ return isSweep+ ? { outcome: 'nothing-to-reconcile' }+ : { outcome: 'nothing-selected' };+ }++ const result = await reconcileUpcomingCalendarEventBatches({+ client,+ calendarEventIds,+ deadlineAtMs:+ startedAtMs + TIMEOUT_SECONDS * 1000 - CONTINUATION_RESERVE_MS,+ });++ return { outcome: 'processed', ...result };+};++export default defineLogicFunction({+ universalIdentifier:+ RECONCILE_UPCOMING_CALENDAR_EVENTS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,+ name: 'reconcile-upcoming-calendar-events',+ description:+ 'Sweeps upcoming calendar events through reconciliation, self-continuing with the remaining ids near the timeout.',+ timeoutSeconds: TIMEOUT_SECONDS,+ handler: reconcileUpcomingCalendarEventsHandler,+ httpRouteTriggerSettings: {+ path: RECONCILE_UPCOMING_CALENDAR_EVENTS_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/start-call-recording-summary-backfill-on-install.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/start-call-recording-summary-backfill-on-install.tsdeleted file mode 100644index eee358a5957..00000000000--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/start-call-recording-summary-backfill-on-install.ts+++ /dev/null@@ -1,34 +0,0 @@-import {- definePostInstallLogicFunction,- type InstallPayload,-} from 'twenty-sdk/define';--import { START_CALL_RECORDING_SUMMARY_BACKFILL_ON_INSTALL_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/start-call-recording-summary-backfill-on-install-logic-function-universal-identifier';-import { requestCallRecordingSummariesBackfill } from 'src/logic-functions/data/request-call-recording-summaries-backfill.util';--export const startCallRecordingSummaryBackfillOnInstallHandler = async ({- previousVersion,-}: InstallPayload): Promise<object> => {- if (previousVersion === undefined) {- return { outcome: 'skipped-initial-install' };- }-- const backfillRequested = await requestCallRecordingSummariesBackfill();-- return {- outcome: backfillRequested- ? 'backfill-requested'- : 'backfill-request-failed',- };-};--export default definePostInstallLogicFunction({- universalIdentifier:- START_CALL_RECORDING_SUMMARY_BACKFILL_ON_INSTALL_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,- name: 'start-call-recording-summary-backfill-on-install',- description:- 'Starts the missing summary backfill worker when Call Recorder is upgraded in a workspace.',- timeoutSeconds: 30,- shouldRunOnVersionUpgrade: true,- handler: startCallRecordingSummaryBackfillOnInstallHandler,-});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/start-post-install-backfills.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/start-post-install-backfills.tsnew file mode 100644index 00000000000..e171dd22f87--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/start-post-install-backfills.ts@@ -0,0 +1,55 @@+import { isUndefined } from '@sniptt/guards';+import {+ definePostInstallLogicFunction,+ type InstallPayload,+} from 'twenty-sdk/define';++import { START_POST_INSTALL_BACKFILLS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/start-post-install-backfills-logic-function-universal-identifier';+import { requestCallRecordingSummariesBackfill } from 'src/logic-functions/data/request-call-recording-summaries-backfill.util';+import { requestUpcomingCalendarEventsReconciliation } from 'src/logic-functions/data/request-upcoming-calendar-events-reconciliation.util';++// An app is allowed a single post-install hook, so the two backfills share it:+// a fresh install seeds the scheduling window, an upgrade relies on the scheduled sweep and backfills summaries.+type StartPostInstallBackfillsResult = {+ calendarEventSweepOutcome: 'sweep-requested' | 'skipped-upgrade';+ summaryBackfillOutcome: 'skipped-initial-install' | 'backfill-requested';+};++export const startPostInstallBackfillsHandler = async ({+ previousVersion,+}: InstallPayload): Promise<StartPostInstallBackfillsResult> => {+ if (isUndefined(previousVersion)) {+ if (!(await requestUpcomingCalendarEventsReconciliation())) {+ throw new Error(+ '[call-recorder] Failed to start post-install backfills: upcoming calendar event sweep',+ );+ }++ return {+ calendarEventSweepOutcome: 'sweep-requested',+ summaryBackfillOutcome: 'skipped-initial-install',+ };+ }++ if (!(await requestCallRecordingSummariesBackfill())) {+ throw new Error(+ '[call-recorder] Failed to start post-install backfills: call recording summary backfill',+ );+ }++ return {+ calendarEventSweepOutcome: 'skipped-upgrade',+ summaryBackfillOutcome: 'backfill-requested',+ };+};++export default definePostInstallLogicFunction({+ universalIdentifier:+ START_POST_INSTALL_BACKFILLS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,+ name: 'start-post-install-backfills',+ description:+ 'Schedules recording bots for upcoming meetings on install, and backfills missing call recording summaries on upgrade.',+ timeoutSeconds: 30,+ shouldRunOnVersionUpgrade: true,+ handler: startPostInstallBackfillsHandler,+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/sweep-upcoming-calendar-events.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/sweep-upcoming-calendar-events.tsnew file mode 100644index 00000000000..36da59f112a--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/sweep-upcoming-calendar-events.ts@@ -0,0 +1,52 @@+import { CoreApiClient } from 'twenty-client-sdk/core';+import { defineLogicFunction } from 'twenty-sdk/define';++import { SWEEP_UPCOMING_CALENDAR_EVENTS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/sweep-upcoming-calendar-events-logic-function-universal-identifier';+import { UPCOMING_CALENDAR_EVENTS_SWEEP_CRON_PATTERN } from 'src/logic-functions/constants/upcoming-calendar-events-sweep-cron-pattern';+import { fetchUpcomingCalendarEventIds } from 'src/logic-functions/data/fetch-upcoming-calendar-event-ids.util';+import { reconcileUpcomingCalendarEventBatches } from 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches.util';+import { type ReconcileUpcomingCalendarEventBatchesResult } from 'src/logic-functions/flows/reconcile-upcoming-calendar-event-batches-result.type';++const TIMEOUT_SECONDS = 900;+const CONTINUATION_RESERVE_MS = 30_000;++type SweepUpcomingCalendarEventsResult =+ | { outcome: 'nothing-to-reconcile' }+ | ({ outcome: 'processed' } & ReconcileUpcomingCalendarEventBatchesResult);++export const sweepUpcomingCalendarEventsHandler =+ async (): Promise<SweepUpcomingCalendarEventsResult> => {+ const startedAtMs = Date.now();+ const client = new CoreApiClient();++ const calendarEventIds = await fetchUpcomingCalendarEventIds(+ client,+ new Date(startedAtMs),+ );++ if (calendarEventIds.length === 0) {+ return { outcome: 'nothing-to-reconcile' };+ }++ const result = await reconcileUpcomingCalendarEventBatches({+ client,+ calendarEventIds,+ deadlineAtMs:+ startedAtMs + TIMEOUT_SECONDS * 1000 - CONTINUATION_RESERVE_MS,+ });++ return { outcome: 'processed', ...result };+ };++export default defineLogicFunction({+ universalIdentifier:+ SWEEP_UPCOMING_CALENDAR_EVENTS_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,+ name: 'sweep-upcoming-calendar-events',+ description:+ 'Reconciles upcoming calendar events on a schedule so meetings entering the scheduling horizon get their recording bots.',+ timeoutSeconds: TIMEOUT_SECONDS,+ handler: sweepUpcomingCalendarEventsHandler,+ cronTriggerSettings: {+ pattern: UPCOMING_CALENDAR_EVENTS_SWEEP_CRON_PATTERN,+ },+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recorder-policy-not-required-reason.type.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recorder-policy-not-required-reason.type.tsindex ec296d17848..2423e57ea40 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recorder-policy-not-required-reason.type.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recorder-policy-not-required-reason.type.ts@@ -2,4 +2,5 @@ export type CallRecorderPolicyNotRequiredReason =| 'EVENT_CANCELED'| 'PREFERENCE_OFF'| 'MISSING_CONFERENCE_LINK'- | 'EVENT_NOT_UPCOMING';+ | 'EVENT_NOT_UPCOMING'+ | 'EVENT_BEYOND_SCHEDULING_HORIZON';