Page MenuHomePhabricator
Differential D14447

[native] Create table and queries for DMOperations
ClosedPublic
Actions

Authored by tomek on Mon, Mar 17, 6:47 AM.
Tags
None
Referenced Files
F4950833: D14447.diff
Thu, Mar 20, 10:27 AM
Unknown Object (File)
Wed, Mar 19, 9:06 PM
Unknown Object (File)
Mon, Mar 17, 8:25 AM
Subscribers
ashoat

Details

Reviewers
kamil
bartek
Commits
rCOMM1ec1670833cf: [native] Create table and queries for DMOperations
Summary

Create a table where the operations are stored and allow quick query by the operation type.

https://linear.app/comm/issue/ENG-10333/create-sqlite-table-and-queries

Test Plan

Tested the whole stack on both native and web:

  1. Run the app on Redux version 86 with a modification to processDMOperation making all the INBOUND messages unsupported
  2. On one platform created a thread and sent a text message. These were visible on the sender, and invisible on the recipient
  3. Closed the recipient and added a migration that unshimms the thread creation operations, e.g.
unshimDMOperations(
  state,
  dmOperationTypes.CREATE_THREAD,
  handleReduxMigrationFailure,
): MigrationFunction<WebNavInfo, AppState>),
  1. Run the recipient and noticed the thread appearing
  2. Added another migration, this time unshimming text messages
  3. Run the recipient and noticed messages appearing

Additionally, tested the migration on native by removing the table from the code that creates the DB, bumping the version to make sure that the migration is run, and adding some code in JS that queries the table.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

tomek created this revision.Mon, Mar 17, 6:47 AM
Herald added a subscriber: ashoat. · View Herald TranscriptMon, Mar 17, 6:47 AM
tomek added a child revision: D14448: [native] Add DMOperation operations to the C++ layer.Mon, Mar 17, 6:49 AM
Harbormaster returned this revision to the author for changes because remote builds failed.Mon, Mar 17, 6:58 AM
Harbormaster failed remote builds in B33723: Diff 47412!
tomek updated this revision to Diff 47425.Mon, Mar 17, 7:23 AM

Update WASM

Harbormaster returned this revision to the author for changes because remote builds failed.Mon, Mar 17, 7:57 AM
Harbormaster failed remote builds in B33735: Diff 47425!
Harbormaster completed remote builds in B33735: Diff 47425.Tue, Mar 18, 3:42 AM
tomek requested review of this revision.Tue, Mar 18, 3:42 AM
kamil accepted this revision.Tue, Mar 18, 7:31 AM
kamil added inline comments.
native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
1032

nit: to follow convention

native/cpp/CommonCpp/DatabaseManagers/entities/DMOperation.h
7–8

I would add a newline here but in the codebase we use both

This revision is now accepted and ready to land.Tue, Mar 18, 7:31 AM
tomek updated this revision to Diff 47453.Wed, Mar 19, 5:24 AM

Rename index

Harbormaster failed remote builds in B33761: Diff 47453!Wed, Mar 19, 5:36 AM
Harbormaster completed remote builds in B33761: Diff 47453.Wed, Mar 19, 5:58 AM
Closed by commit rCOMM1ec1670833cf: [native] Create table and queries for DMOperations (authored by tomek). · Explain WhyWed, Mar 19, 9:56 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMM1ec1670833cf: [native] Create table and queries for DMOperations.

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
DatabaseManagers/
8 lines
7 lines
75 lines
entities/
27 lines
ios/
Comm.xcodeproj/
2 lines
web/
shared-worker/
_generated/

Diff 47425

View Options

native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h

// @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/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h

// @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/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp

// @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/cpp/CommonCpp/DatabaseManagers/entities/DMOperation.h

// @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/ios/Comm.xcodeproj/project.pbxproj

// @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/shared-worker/_generated/comm_query_executor.wasm

// @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 };