Paths

Table of Contentst

-
lib/reducers/
-
reducers/
-
dm-operations-queue-reducer.js
-
master-reducer.js

[lib] Handle ops in the reducer
ClosedPublic
Actions

Authored by tomek on Mon, Mar 17, 7:02 AM.

Details

Reviewers

kamil
bartek

Commits

rCOMMdec6602b77a8: [lib] Handle ops in the reducer

Summary

Allow the reducer to return operations.

https://linear.app/comm/issue/ENG-10331/modify-the-reducer-to-support-the-db-operations

Depends on D14452

Test Plan

Tested the whole stack on both native and web:

Run the app on Redux version 86 with a modification to processDMOperation making all the INBOUND messages unsupported
On one platform created a thread and sent a text message. These were visible on the sender, and invisible on the recipient
Closed the recipient and added a migration that unshimms the thread creation operations, e.g.

unshimDMOperations(
  state,
  dmOperationTypes.CREATE_THREAD,
  handleReduxMigrationFailure,
): MigrationFunction<WebNavInfo, AppState>),

Run the recipient and noticed the thread appearing
Added another migration, this time unshimming text messages
Run the recipient and noticed messages appearing

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

tomek created this revision.Mon, Mar 17, 7:02 AM

Herald added a subscriber: ashoat. · View Herald TranscriptMon, Mar 17, 7:02 AM

tomek added a child revision: D14454: [lib] Save unsupported operations in the DB.Mon, Mar 17, 7:05 AM

Harbormaster returned this revision to the author for changes because remote builds failed.Mon, Mar 17, 7:28 AM

Harbormaster failed remote builds in B33729: Diff 47418!

Rebase

Harbormaster completed remote builds in B33756: Diff 47446.Tue, Mar 18, 3:59 AM

tomek requested review of this revision.Tue, Mar 18, 3:59 AM

kamil accepted this revision.Tue, Mar 18, 7:48 AM

This revision is now accepted and ready to land.Tue, Mar 18, 7:48 AM

Closed by commit rCOMMdec6602b77a8: [lib] Handle ops in the reducer (authored by tomek). · Explain WhyWed, Mar 19, 9:57 AM

This revision was automatically updated to reflect the committed changes.

tomek added a commit: rCOMMdec6602b77a8: [lib] Handle ops in the reducer.

Revision Contents
Changeset List

Path

Size

lib/

reducers/

dm-operations-queue-reducer.js

155 lines

master-reducer.js

9 lines

Diff 47418

View Options

lib/reducers/dm-operations-queue-reducer.js

	// @flow			// @flow

	import _mapValues from 'lodash/fp/mapValues.js';			import _mapValues from 'lodash/fp/mapValues.js';

				import type { DMOperationStoreOperation } from '../ops/dm-operations-store-ops.js';
	import {			import {
	clearQueuedEntryDMOpsActionType,			clearQueuedEntryDMOpsActionType,
	clearQueuedMembershipDMOpsActionType,			clearQueuedMembershipDMOpsActionType,
	clearQueuedMessageDMOpsActionType,			clearQueuedMessageDMOpsActionType,
	clearQueuedThreadDMOpsActionType,			clearQueuedThreadDMOpsActionType,
	type OperationsQueue,			type OperationsQueue,
	pruneDMOpsQueueActionType,			pruneDMOpsQueueActionType,
	type QueuedDMOperations,			type QueuedDMOperations,
	queueDMOpsActionType,			queueDMOpsActionType,
	} from '../types/dm-ops.js';			} from '../types/dm-ops.js';
	import type { BaseAction } from '../types/redux-types.js';			import type { BaseAction } from '../types/redux-types.js';

	function reduceDMOperationsQueue(			function reduceDMOperationsQueue(
	store: QueuedDMOperations,			store: QueuedDMOperations,
	action: BaseAction,			action: BaseAction,
	): QueuedDMOperations {			): {
				+store: QueuedDMOperations,
				+operations: $ReadOnlyArray<DMOperationStoreOperation>,
				} {
	if (action.type === queueDMOpsActionType) {			if (action.type === queueDMOpsActionType) {
	const { condition, operation, timestamp } = action.payload;			const { condition, operation, timestamp } = action.payload;

	if (condition.type === 'thread') {			if (condition.type === 'thread') {
	return {			return {
				store: {
	...store,			...store,
	threadQueue: {			threadQueue: {
	...store.threadQueue,			...store.threadQueue,
	[condition.threadID]: [			[condition.threadID]: [
	...(store.threadQueue[condition.threadID] ?? []),			...(store.threadQueue[condition.threadID] ?? []),
	{ operation, timestamp },			{ operation, timestamp },
	],			],
	},			},
				},
				operations: [],
	};			};
	}			}

	if (condition.type === 'entry') {			if (condition.type === 'entry') {
	return {			return {
				store: {
	...store,			...store,
	entryQueue: {			entryQueue: {
	...store.entryQueue,			...store.entryQueue,
	[condition.entryID]: [			[condition.entryID]: [
	...(store.entryQueue[condition.entryID] ?? []),			...(store.entryQueue[condition.entryID] ?? []),
	{ operation, timestamp },			{ operation, timestamp },
	],			],
	},			},
				},
				operations: [],
	};			};
	}			}

	if (condition.type === 'message') {			if (condition.type === 'message') {
	return {			return {
				store: {
	...store,			...store,
	messageQueue: {			messageQueue: {
	...store.messageQueue,			...store.messageQueue,
	[condition.messageID]: [			[condition.messageID]: [
	...(store.messageQueue[condition.messageID] ?? []),			...(store.messageQueue[condition.messageID] ?? []),
	{ operation, timestamp },			{ operation, timestamp },
	],			],
	},			},
				},
				operations: [],
	};			};
	}			}

	return {			return {
				store: {
	...store,			...store,
	membershipQueue: {			membershipQueue: {
	...store.membershipQueue,			...store.membershipQueue,
	[condition.threadID]: {			[condition.threadID]: {
	...(store.membershipQueue[condition.threadID] ?? {}),			...(store.membershipQueue[condition.threadID] ?? {}),
	[condition.userID]: [			[condition.userID]: [
	...(store.membershipQueue[condition.threadID]?.[condition.userID] ??			...(store.membershipQueue[condition.threadID]?.[
	[]),			condition.userID
				] ?? []),
	{ operation, timestamp },			{ operation, timestamp },
	],			],
	},			},
	},			},
				},
				operations: [],
	};			};
	} else if (action.type === pruneDMOpsQueueActionType) {			} else if (action.type === pruneDMOpsQueueActionType) {
	const filterOperations = (queue: OperationsQueue) =>			const filterOperations = (queue: OperationsQueue) =>
	queue.filter(op => op.timestamp >= action.payload.pruneMaxTimestamp);			queue.filter(op => op.timestamp >= action.payload.pruneMaxTimestamp);
	return {			return {
				store: {
	...store,			...store,
	threadQueue: _mapValues(operations => filterOperations(operations))(			threadQueue: _mapValues(operations => filterOperations(operations))(
	store.threadQueue,			store.threadQueue,
	),			),
	messageQueue: _mapValues(operations => filterOperations(operations))(			messageQueue: _mapValues(operations => filterOperations(operations))(
	store.messageQueue,			store.messageQueue,
	),			),
	entryQueue: _mapValues(operations => filterOperations(operations))(			entryQueue: _mapValues(operations => filterOperations(operations))(
	store.entryQueue,			store.entryQueue,
	),			),
	membershipQueue: _mapValues(threadMembershipQueue =>			membershipQueue: _mapValues(threadMembershipQueue =>
	_mapValues(operations => filterOperations(operations))(			_mapValues(operations => filterOperations(operations))(
	threadMembershipQueue,			threadMembershipQueue,
	),			),
	)(store.membershipQueue),			)(store.membershipQueue),
				},
				operations: [],
	};			};
	} else if (action.type === clearQueuedThreadDMOpsActionType) {			} else if (action.type === clearQueuedThreadDMOpsActionType) {
	const { [action.payload.threadID]: removed, ...threadQueue } =			const { [action.payload.threadID]: removed, ...threadQueue } =
	store.threadQueue;			store.threadQueue;
	return {			return {
				store: {
	...store,			...store,
	threadQueue,			threadQueue,
				},
				operations: [],
	};			};
	} else if (action.type === clearQueuedMessageDMOpsActionType) {			} else if (action.type === clearQueuedMessageDMOpsActionType) {
	const { [action.payload.messageID]: removed, ...messageQueue } =			const { [action.payload.messageID]: removed, ...messageQueue } =
	store.messageQueue;			store.messageQueue;
	return {			return {
				store: {
	...store,			...store,
	messageQueue,			messageQueue,
				},
				operations: [],
	};			};
	} else if (action.type === clearQueuedEntryDMOpsActionType) {			} else if (action.type === clearQueuedEntryDMOpsActionType) {
	const { [action.payload.entryID]: removed, ...entryQueue } =			const { [action.payload.entryID]: removed, ...entryQueue } =
	store.entryQueue;			store.entryQueue;
	return {			return {
				store: {
	...store,			...store,
	entryQueue,			entryQueue,
				},
				operations: [],
	};			};
	} else if (action.type === clearQueuedMembershipDMOpsActionType) {			} else if (action.type === clearQueuedMembershipDMOpsActionType) {
	const threadQueue = store.membershipQueue[action.payload.threadID];			const threadQueue = store.membershipQueue[action.payload.threadID];
	if (!threadQueue) {			if (!threadQueue) {
	return store;			return { store, operations: [] };
	}			}

	const { [action.payload.userID]: removed, ...queue } = threadQueue;			const { [action.payload.userID]: removed, ...queue } = threadQueue;
	if (Object.keys(queue).length === 0) {			if (Object.keys(queue).length === 0) {
	const { [action.payload.threadID]: removedThread, ...membershipQueue } =			const { [action.payload.threadID]: removedThread, ...membershipQueue } =
	store.membershipQueue;			store.membershipQueue;
	return {			return {
				store: {
	...store,			...store,
	membershipQueue,			membershipQueue,
				},
				operations: [],
	};			};
	}			}

	return {			return {
				store: {
	...store,			...store,
	membershipQueue: {			membershipQueue: {
	...store.membershipQueue,			...store.membershipQueue,
	[action.payload.userID]: queue,			[action.payload.userID]: queue,
	},			},
				},
				operations: [],
	};			};
	}			}
	return store;			return { store, operations: [] };
	}			}

	export { reduceDMOperationsQueue };			export { reduceDMOperationsQueue };