Page MenuHomePhabricator
Differential D14446

[native] flip showCommunityDirectory to true
AcceptedPublic
Actions

Authored by varun on Sun, Mar 16, 3:13 PM.

Details

Reviewers
ashoat
Summary

once ENG-10291: Launch and test community directory in production is closed out, we can land this change

Depends on D14445

Test Plan

N/A

Diff Detail

Repository
rCOMM Comm
Branch
master
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
native/
utils/
2 lines

Diff 47411

View Options

native/utils/directory-utils.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 };