Page MenuHomePhabricator
Differential D14451

[web] Add support for DM operations to the shared worker
ClosedPublic
Actions

Authored by tomek on Mon, Mar 17, 6:57 AM.
Tags
None
Referenced Files
F4953345: D14451.diff
Fri, Mar 21, 1:16 AM
F4953174: D14451.id47429.diff
Fri, Mar 21, 12:24 AM
F4951036: D14451.diff
Thu, Mar 20, 11:57 AM
F4950930: D14451.diff
Thu, Mar 20, 10:57 AM
Unknown Object (File)
Wed, Mar 19, 9:50 PM
Unknown Object (File)
Mon, Mar 17, 8:25 AM
Unknown Object (File)
Mon, Mar 17, 8:25 AM
Unknown Object (File)
Mon, Mar 17, 8:23 AM
View All 9 Files
Subscribers
ashoat

Details

Reviewers
kamil
bartek
Commits
rCOMM64bf51bbef0f: [web] Add support for DM operations to the shared worker
Summary

Handle the new operations on the shared worker.

https://linear.app/comm/issue/ENG-10334/update-jsi-and-web-worker-code-to-support-new-db-operations

Depends on D14450

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

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
web/
shared-worker/
worker/
46 lines
10 lines
types/
19 lines

Diff 47429

View Options

web/shared-worker/worker/process-operations.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/shared-worker/worker/shared-worker.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/types/worker-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 };