Paths

Table of Contentst

-
lib/
-
types/
-
sqlite-types.js
-
utils/__mocks__/
-
__mocks__/
-
config.js
-
native/database/
-
database/
-
sqlite-api.js
-
web/database/
-
database/
-
sqlite-api.js

[native][web] Include fetching DM operations in SQLite API
ClosedPublic
Actions

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

Details

Reviewers

kamil
bartek

Commits

rCOMMddc042ca13e8: [native][web] Include fetching DM operations in SQLite API

Summary

We're going to fetch the operation in the lib code, so we have to include the code in the SQLite API.

https://linear.app/comm/issue/ENG-10335/prepare-utils-to-unshim-operations-in-a-migration

Depends on D14454

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:07 AM

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

tomek added a child revision: D14457: [lib] Create unshimming queue.Mon, Mar 17, 7:10 AM

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

Harbormaster failed remote builds in B33732: Diff 47421!

Rebase

Harbormaster completed remote builds in B33758: Diff 47448.Tue, Mar 18, 4:04 AM

tomek requested review of this revision.Tue, Mar 18, 4:04 AM

kamil accepted this revision.Tue, Mar 18, 8:11 AM

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

Closed by commit rCOMMddc042ca13e8: [native][web] Include fetching DM operations in SQLite API (authored by tomek). · Explain WhyWed, Mar 19, 9:57 AM

This revision was automatically updated to reflect the committed changes.

tomek added a commit: rCOMMddc042ca13e8: [native][web] Include fetching DM operations in SQLite API.

Revision Contents
Changeset List

Path

Size

lib/

types/

sqlite-types.js

4 lines

utils/

__mocks__/

config.js

1 line

native/

database/

sqlite-api.js

1 line

web/

database/

sqlite-api.js

14 lines

Diff 47421

View Options

lib/types/sqlite-types.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 };

View Options

lib/utils/mocks/config.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 };

View Options

native/database/sqlite-api.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 };

View Options

web/database/sqlite-api.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 };

[native][web] Include fetching DM operations in SQLite APIClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 47421

lib/types/sqlite-types.js

lib/utils/__mocks__/config.js

native/database/sqlite-api.js

web/database/sqlite-api.js

[native][web] Include fetching DM operations in SQLite API
ClosedPublic
Actions

Revision Contents
Changeset List

lib/utils/mocks/config.js