Merge branch 'feat/MM-65147-upgrade-react-native-0773' into fix/MM-66825-16kb-pagesize

Author: rahimrahman

.github/actions/prepare-ios-build/action.yaml

@@ -45,8 +45,9 @@ runs:
         path: |
           ios/Pods
           libraries/@mattermost/intune/ios/Frameworks
-        key: ${{ runner.os }}-pods-v3-intune-${{ inputs.intune-enabled }}-${{ steps.intune-hash.outputs.hash }}-${{ hashFiles('ios/Podfile.lock') }}
+        key: ${{ runner.os }}-pods-v3-intune-${{ inputs.intune-enabled }}-${{ steps.intune-hash.outputs.hash }}-${{ hashFiles('ios/Podfile.lock') }}-${{ github.ref_name }}
         restore-keys: |
+          ${{ runner.os }}-pods-v3-intune-${{ inputs.intune-enabled }}-${{ steps.intune-hash.outputs.hash }}-${{ hashFiles('ios/Podfile.lock') }}-
           ${{ runner.os }}-pods-v3-intune-${{ inputs.intune-enabled }}-${{ steps.intune-hash.outputs.hash }}-
           ${{ runner.os }}-pods-v3-intune-${{ inputs.intune-enabled }}-
 

app/actions/local/systems.test.ts

@@ -3,10 +3,13 @@
 
 import Database from '@nozbe/watermelondb/Database';
 
+import {getPosts} from '@actions/local/post';
 import {ActionType} from '@constants';
 import {SYSTEM_IDENTIFIERS} from '@constants/database';
+import {PostTypes} from '@constants/post';
 import DatabaseManager from '@database/manager';
 import TestHelper from '@test/test_helper';
+import {logError} from '@utils/log';
 
 import {
     storeConfig,
@@ -17,6 +20,7 @@ import {
     setLastServerVersionCheck,
     setGlobalThreadsTab,
     dismissAnnouncement,
+    expiredBoRPostCleanup,
 } from './systems';
 
 import type {DataRetentionPoliciesRequest} from '@actions/remote/systems';
@@ -251,3 +255,269 @@ describe('dismissAnnouncement', () => {
     });
 });
 
+describe('expiredBoRPostCleanup', () => {
+    it('should delete expired BoR posts', async () => {
+        const database = operator.database;
+        jest.spyOn(database.adapter, 'unsafeExecute').mockImplementation(() => Promise.resolve());
+
+        const channel: Channel = TestHelper.fakeChannel({
+            id: 'channelid1',
+            team_id: 'teamid1',
+        });
+        await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
+
+        const now = Date.now();
+
+        const borPostExpiredForAll = TestHelper.fakePost({
+            id: 'postid1',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now - 10000},
+        });
+
+        const borPostExpiredForMe = TestHelper.fakePost({
+            id: 'postid2',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now + 100000},
+            metadata: {expire_at: now - 10000},
+        });
+
+        await operator.handlePosts({
+            actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL,
+            order: [borPostExpiredForAll.id, borPostExpiredForMe.id],
+            posts: [borPostExpiredForAll, borPostExpiredForMe],
+            prepareRecordsOnly: false,
+        });
+
+        // verify channel posts
+        const fetchedPosts = await getPosts(serverUrl, [borPostExpiredForAll.id, borPostExpiredForMe.id]);
+        expect(fetchedPosts.length).toBe(2);
+
+        await expiredBoRPostCleanup(serverUrl);
+
+        expect(database.adapter.unsafeExecute).toHaveBeenCalledWith({
+            sqls: [
+                [`DELETE FROM Post where id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM Reaction where post_id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM File where post_id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM Draft where root_id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM PostsInThread where root_id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM Thread where id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM ThreadParticipant where thread_id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+                [`DELETE FROM ThreadsInTeam where thread_id IN ('${borPostExpiredForMe.id}','${borPostExpiredForAll.id}')`, []],
+            ],
+        });
+    });
+
+    it('should not run cleanup when called again within 15 minutes', async () => {
+        const database = operator.database;
+        const unsafeExecuteSpy = jest.spyOn(database.adapter, 'unsafeExecute').mockImplementation(() => Promise.resolve());
+
+        // Set up a recent last run time (within 15 minutes)
+        const recentRunTime = Date.now() - (10 * 60 * 1000); // 10 minutes ago
+        await operator.handleSystem({
+            systems: [{
+                id: SYSTEM_IDENTIFIERS.LAST_BOR_POST_CLEANUP_RUN,
+                value: recentRunTime,
+            }],
+            prepareRecordsOnly: false,
+        });
+
+        const channel: Channel = TestHelper.fakeChannel({
+            id: 'channelid1',
+            team_id: 'teamid1',
+        });
+        await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
+
+        const now = Date.now();
+        const borPostExpired = TestHelper.fakePost({
+            id: 'postid1',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now - 10000},
+        });
+
+        await operator.handlePosts({
+            actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL,
+            order: [borPostExpired.id],
+            posts: [borPostExpired],
+            prepareRecordsOnly: false,
+        });
+
+        // Call cleanup - should not run because last run was within 15 minutes
+        await expiredBoRPostCleanup(serverUrl);
+
+        // Verify that unsafeExecute was not called (no cleanup performed)
+        expect(unsafeExecuteSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle no server database gracefully', async () => {
+        // Try to run cleanup on a non-existent server
+        await expect(expiredBoRPostCleanup('nonexistent.server.com')).resolves.not.toThrow();
+    });
+
+    it('should handle no BoR posts gracefully', async () => {
+        const database = operator.database;
+        const unsafeExecuteSpy = jest.spyOn(database.adapter, 'unsafeExecute').mockImplementation(() => Promise.resolve());
+
+        const channel: Channel = TestHelper.fakeChannel({
+            id: 'channelid1',
+            team_id: 'teamid1',
+        });
+        await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
+        await expiredBoRPostCleanup(serverUrl);
+
+        // Verify that unsafeExecute was not called (no BoR posts to clean)
+        expect(unsafeExecuteSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle BoR posts that are not expired', async () => {
+        const database = operator.database;
+        const unsafeExecuteSpy = jest.spyOn(database.adapter, 'unsafeExecute').mockImplementation(() => Promise.resolve());
+
+        const channel: Channel = TestHelper.fakeChannel({
+            id: 'channelid1',
+            team_id: 'teamid1',
+        });
+        await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
+
+        const now = Date.now();
+
+        // Create BoR posts that are not expired
+        const borPostNotExpired = TestHelper.fakePost({
+            id: 'postid1',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now + 100000}, // Future expiry
+        });
+
+        const borPostNotExpiredForMe = TestHelper.fakePost({
+            id: 'postid2',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now + 10000},
+            metadata: {expire_at: now + 100000},
+        });
+
+        await operator.handlePosts({
+            actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL,
+            order: [borPostNotExpired.id, borPostNotExpiredForMe.id],
+            posts: [borPostNotExpired, borPostNotExpiredForMe],
+            prepareRecordsOnly: false,
+        });
+
+        await expiredBoRPostCleanup(serverUrl);
+
+        // Verify that unsafeExecute was not called (no expired BoR posts)
+        expect(unsafeExecuteSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle mixed expired and non-expired BoR posts', async () => {
+        const database = operator.database;
+        jest.spyOn(database.adapter, 'unsafeExecute').mockImplementation(() => Promise.resolve());
+
+        const channel: Channel = TestHelper.fakeChannel({
+            id: 'channelid1',
+            team_id: 'teamid1',
+        });
+        await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
+
+        const now = Date.now();
+
+        const borPostExpired = TestHelper.fakePost({
+            id: 'postid1',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now - 10000}, // Expired
+        });
+
+        const borPostNotExpired = TestHelper.fakePost({
+            id: 'postid2',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now + 100000}, // Not expired
+        });
+
+        await operator.handlePosts({
+            actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL,
+            order: [borPostExpired.id, borPostNotExpired.id],
+            posts: [borPostExpired, borPostNotExpired],
+            prepareRecordsOnly: false,
+        });
+
+        await expiredBoRPostCleanup(serverUrl);
+
+        // Should only delete the expired post
+        expect(database.adapter.unsafeExecute).toHaveBeenCalledWith({
+            sqls: [
+                [`DELETE FROM Post where id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM Reaction where post_id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM File where post_id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM Draft where root_id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM PostsInThread where root_id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM Thread where id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM ThreadParticipant where thread_id IN ('${borPostExpired.id}')`, []],
+                [`DELETE FROM ThreadsInTeam where thread_id IN ('${borPostExpired.id}')`, []],
+            ],
+        });
+    });
+
+    it('should handle database errors gracefully', async () => {
+        const database = operator.database;
+
+        // Mock database query to throw an error
+        jest.spyOn(database, 'get').mockImplementation(() => {
+            throw new Error('Database error');
+        });
+
+        // Should not throw an error, just log it
+        await expect(expiredBoRPostCleanup(serverUrl)).resolves.not.toThrow();
+        expect(logError).toHaveBeenCalledWith('An error occurred while performing BoR post cleanup', expect.any(Error));
+    });
+
+    it('should handle updateLastBoRCleanupRun error gracefully', async () => {
+        const database = operator.database;
+        jest.spyOn(database.adapter, 'unsafeExecute').mockImplementation(() => Promise.resolve());
+
+        // Mock handleSystem to throw an error when updating last cleanup run
+        const handleSystemSpy = jest.spyOn(operator, 'handleSystem').mockImplementation(() => {
+            throw new Error('System update error');
+        });
+
+        const channel: Channel = TestHelper.fakeChannel({
+            id: 'channelid1',
+            team_id: 'teamid1',
+        });
+        await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
+
+        // Restore handleSystem for channel creation, then mock it again for the cleanup run update
+        handleSystemSpy.mockRestore();
+        jest.spyOn(operator, 'handleSystem').mockImplementation((args) => {
+            if (args.systems?.[0]?.id === SYSTEM_IDENTIFIERS.LAST_BOR_POST_CLEANUP_RUN) {
+                throw new Error('System update error');
+            }
+            return Promise.resolve([]);
+        });
+
+        const now = Date.now();
+        const borPostExpired = TestHelper.fakePost({
+            id: 'postid1',
+            channel_id: channel.id,
+            type: PostTypes.BURN_ON_READ,
+            props: {expire_at: now - 10000},
+        });
+
+        await operator.handlePosts({
+            actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL,
+            order: [borPostExpired.id],
+            posts: [borPostExpired],
+            prepareRecordsOnly: false,
+        });
+
+        // Should not throw an error, just log it
+        await expect(expiredBoRPostCleanup(serverUrl)).resolves.not.toThrow();
+        expect(logError).toHaveBeenCalledWith('Failed updateLastBoRCleanupRun', expect.any(Error));
+    });
+
+});

app/actions/local/systems.ts

@@ -7,11 +7,22 @@ import {DeviceEventEmitter} from 'react-native';
 
 import {Events} from '@constants';
 import {MM_TABLES, SYSTEM_IDENTIFIERS} from '@constants/database';
+import {PostTypes, BOR_POST_CLEANUP_MIN_RUN_INTERVAL} from '@constants/post';
 import DatabaseManager from '@database/manager';
 import {getServerCredentials} from '@init/credentials';
 import {queryAllChannelsForTeam} from '@queries/servers/channel';
-import {getConfig, getLicense, getGlobalDataRetentionPolicy, getGranularDataRetentionPolicies, getLastGlobalDataRetentionRun, getIsDataRetentionEnabled} from '@queries/servers/system';
+import {queryPostsByType} from '@queries/servers/post';
+import {
+    getConfig,
+    getLicense,
+    getGlobalDataRetentionPolicy,
+    getGranularDataRetentionPolicies,
+    getLastGlobalDataRetentionRun,
+    getIsDataRetentionEnabled,
+    getLastBoRPostCleanupRun,
+} from '@queries/servers/system';
 import PostModel from '@typings/database/models/servers/post';
+import {isExpiredBoRPost} from '@utils/bor';
 import {logError} from '@utils/log';
 
 import {deletePosts} from './post';
@@ -239,7 +250,7 @@ async function dataRetentionWithoutPolicyCleanup(serverUrl: string) {
     }
 }
 
-async function dataRetentionCleanPosts(serverUrl: string, postIds: string[]) {
+export async function dataRetentionCleanPosts(serverUrl: string, postIds: string[]) {
     if (postIds.length) {
         const batchSize = 1000;
         const deletePromises = [];
@@ -314,3 +325,55 @@ export async function dismissAnnouncement(serverUrl: string, announcementText: s
         return {error};
     }
 }
+
+export async function expiredBoRPostCleanup(serverUrl: string) {
+    try {
+        const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
+        const lastRunAt = await getLastBoRPostCleanupRun(database);
+
+        const shouldRunNow = (Date.now() - lastRunAt) > BOR_POST_CLEANUP_MIN_RUN_INTERVAL;
+
+        if (!shouldRunNow) {
+            return;
+        }
+
+        const {error} = await removeExpiredBoRPosts(serverUrl);
+        if (!error) {
+            await updateLastBoRCleanupRun(serverUrl);
+        }
+    } catch (error) {
+        logError('An error occurred running the Burn on Read cleanup task', error);
+    }
+}
+
+async function removeExpiredBoRPosts(serverUrl: string) {
+    try {
+        const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
+        const allBoRPosts = await queryPostsByType(database, PostTypes.BURN_ON_READ).fetch();
+        const expiredBoRPostIDs = allBoRPosts.
+            filter((post) => isExpiredBoRPost(post)).
+            map((post) => post.id);
+
+        await dataRetentionCleanPosts(serverUrl, expiredBoRPostIDs);
+        return {error: undefined};
+    } catch (error) {
+        logError('An error occurred while performing BoR post cleanup', error);
+        return {error};
+    }
+}
+
+async function updateLastBoRCleanupRun(serverUrl: string) {
+    try {
+        const {operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
+
+        const systems: IdValue[] = [{
+            id: SYSTEM_IDENTIFIERS.LAST_BOR_POST_CLEANUP_RUN,
+            value: Date.now(),
+        }];
+
+        return operator.handleSystem({systems, prepareRecordsOnly: false});
+    } catch (error) {
+        logError('Failed updateLastBoRCleanupRun', error);
+        return {error};
+    }
+}