[Services] Remove build_services compatibility logic
ClosedPublic
Actions

// @flow		// @flow

import invariant from 'invariant';		import invariant from 'invariant';
import uuid from 'uuid';		import uuid from 'uuid';

import {
type AddMembersResult,
createAddNewMembersResults,
createAddNewMembersMessageDataFromDMOperation,
} from './add-members-spec.js';
import type {		import type {
DMOperationSpec,		DMOperationSpec,
ProcessDMOperationUtilities,		ProcessDMOperationUtilities,
} from './dm-op-spec.js';		} from './dm-op-spec.js';
import type {		import type {
DMChangeThreadSettingsAndAddViewerOperation,
DMChangeThreadSettingsOperation,		DMChangeThreadSettingsOperation,
DMOperationResult,		DMThreadSettingsChanges,
DMThreadSettingsChangesBase,
} from '../../types/dm-ops.js';		} from '../../types/dm-ops.js';
import type { MessageData, RawMessageInfo } from '../../types/message-types';		import type { MessageData, RawMessageInfo } from '../../types/message-types';
import { messageTypes } from '../../types/message-types-enum.js';		import { messageTypes } from '../../types/message-types-enum.js';
import type { ChangeSettingsMessageData } from '../../types/messages/change-settings.js';		import type { ChangeSettingsMessageData } from '../../types/messages/change-settings.js';
import type { RawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';		import type { RawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import { updateTypes } from '../../types/update-types-enum.js';		import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js';		import type { ClientUpdateInfo } from '../../types/update-types.js';
import { values } from '../../utils/objects.js';		import { values } from '../../utils/objects.js';
import { rawMessageInfoFromMessageData } from '../message-utils.js';		import { rawMessageInfoFromMessageData } from '../message-utils.js';

function createAddMembersOperation(
dmOperation: DMChangeThreadSettingsOperation,
) {
const { editorID, time, messageIDsPrefix, changes, threadID } = dmOperation;
const newMemberIDs =
changes.newMemberIDs && changes.newMemberIDs.length > 0
? [...new Set(changes.newMemberIDs)]
: [];
if (!changes.newMemberIDs \|\| changes.newMemberIDs.length === 0) {
return null;
}
return {
type: 'add_members',
editorID,
time,
messageID: `${messageIDsPrefix}/add_members`,
addedUserIDs: newMemberIDs,
threadID,
};
}

function processAddMembersOperation(
dmOperation: DMChangeThreadSettingsOperation,
viewerID: string,
utilities: ProcessDMOperationUtilities,
) {
const operation = createAddMembersOperation(dmOperation);
if (!operation) {
return null;
}
return createAddNewMembersResults(operation, viewerID, utilities);
}

function getThreadIDFromChangeThreadSettingsDMOp(		function getThreadIDFromChangeThreadSettingsDMOp(
dmOperation:		dmOperation: DMChangeThreadSettingsOperation,
\| DMChangeThreadSettingsOperation
\| DMChangeThreadSettingsAndAddViewerOperation,
): string {		): string {
return dmOperation.type === 'change_thread_settings'		return dmOperation.type === 'change_thread_settings'
? dmOperation.threadID		? dmOperation.threadID
: dmOperation.existingThreadDetails.threadID;		: dmOperation.existingThreadDetails.threadID;
}		}

function createChangeSettingsMessageDatasAndUpdate(		function createChangeSettingsMessageDatasAndUpdate(
dmOperation:		dmOperation: DMChangeThreadSettingsOperation,
\| DMChangeThreadSettingsOperation
\| DMChangeThreadSettingsAndAddViewerOperation,
): {		): {
+fieldNameToMessageData: { +[fieldName: string]: ChangeSettingsMessageData },		+fieldNameToMessageData: { +[fieldName: string]: ChangeSettingsMessageData },
+threadInfoUpdate: DMThreadSettingsChangesBase,		+threadInfoUpdate: DMThreadSettingsChanges,
} {		} {
const { changes, editorID, time } = dmOperation;		const { changes, editorID, time } = dmOperation;
const { name, description, color, avatar } = changes;		const { name, description, color, avatar } = changes;
const threadID = getThreadIDFromChangeThreadSettingsDMOp(dmOperation);		const threadID = getThreadIDFromChangeThreadSettingsDMOp(dmOperation);

const threadInfoUpdate: { ...DMThreadSettingsChangesBase } = {};		const threadInfoUpdate: { ...DMThreadSettingsChanges } = {};

if (name !== undefined && name !== null) {		if (name !== undefined && name !== null) {
threadInfoUpdate.name = name;		threadInfoUpdate.name = name;
}		}

if (description !== undefined && description !== null) {		if (description !== undefined && description !== null) {
threadInfoUpdate.description = description;		threadInfoUpdate.description = description;
}		}
Show All 25 Lines	fieldNameToMessageData[fieldName] = {
field: fieldName,		field: fieldName,
value: value,		value: value,
};		};
}		}

return { fieldNameToMessageData, threadInfoUpdate };		return { fieldNameToMessageData, threadInfoUpdate };
}		}

function processChangeSettingsOperation(		const changeThreadSettingsSpec: DMOperationSpec<DMChangeThreadSettingsOperation> =
dmOperation:		Object.freeze({
\| DMChangeThreadSettingsOperation		notificationsCreationData: async (
\| DMChangeThreadSettingsAndAddViewerOperation,		dmOperation: DMChangeThreadSettingsOperation,
		) => {
		const messageDatas: Array<MessageData> = [];

		const { fieldNameToMessageData } =
		createChangeSettingsMessageDatasAndUpdate(dmOperation);
		messageDatas.push(...values(fieldNameToMessageData));
		return { messageDatas };
		},
		processDMOperation: async (
		dmOperation: DMChangeThreadSettingsOperation,
viewerID: string,		viewerID: string,
utilities: ProcessDMOperationUtilities,		utilities: ProcessDMOperationUtilities,
addMembersResult: ?AddMembersResult,		) => {
): DMOperationResult {
const { time, messageIDsPrefix } = dmOperation;		const { time, messageIDsPrefix } = dmOperation;
const threadID = getThreadIDFromChangeThreadSettingsDMOp(dmOperation);		const threadID = getThreadIDFromChangeThreadSettingsDMOp(dmOperation);

let threadInfoToUpdate: ?RawThreadInfo = utilities.threadInfos[threadID];		let threadInfoToUpdate: ?RawThreadInfo = utilities.threadInfos[threadID];
const updateInfos: Array<ClientUpdateInfo> = [];		const updateInfos: Array<ClientUpdateInfo> = [];
const rawMessageInfos: Array<RawMessageInfo> = [];		const rawMessageInfos: Array<RawMessageInfo> = [];

if (addMembersResult) {
if (addMembersResult.threadInfo) {
threadInfoToUpdate = addMembersResult.threadInfo;
}
updateInfos.push(...addMembersResult.updateInfos);
rawMessageInfos.push(...addMembersResult.rawMessageInfos);
}

invariant(threadInfoToUpdate?.thick, 'Thread should be thick');		invariant(threadInfoToUpdate?.thick, 'Thread should be thick');
const { fieldNameToMessageData, threadInfoUpdate } =		const { fieldNameToMessageData, threadInfoUpdate } =
createChangeSettingsMessageDatasAndUpdate(dmOperation);		createChangeSettingsMessageDatasAndUpdate(dmOperation);

const fieldNameToMessageDataPairs = Object.entries(fieldNameToMessageData);		const fieldNameToMessageDataPairs = Object.entries(
		fieldNameToMessageData,
		);
rawMessageInfos.push(		rawMessageInfos.push(
...fieldNameToMessageDataPairs.map(([fieldName, messageData]) =>		...fieldNameToMessageDataPairs.map(([fieldName, messageData]) =>
rawMessageInfoFromMessageData(		rawMessageInfoFromMessageData(
messageData,		messageData,
`${messageIDsPrefix}/${fieldName}`,		`${messageIDsPrefix}/${fieldName}`,
),		),
),		),
);		);

threadInfoToUpdate = {		threadInfoToUpdate = {
...threadInfoToUpdate,		...threadInfoToUpdate,
...threadInfoUpdate,		...threadInfoUpdate,
};		};

if (fieldNameToMessageDataPairs.length > 0) {		if (fieldNameToMessageDataPairs.length > 0) {
updateInfos.push({		updateInfos.push({
type: updateTypes.UPDATE_THREAD,		type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),		id: uuid.v4(),
time,		time,
threadInfo: threadInfoToUpdate,		threadInfo: threadInfoToUpdate,
});		});
}		}

return {		return {
rawMessageInfos,		rawMessageInfos,
updateInfos,		updateInfos,
};		};
}

const changeThreadSettingsSpec: DMOperationSpec<DMChangeThreadSettingsOperation> =
Object.freeze({
notificationsCreationData: async (
dmOperation: DMChangeThreadSettingsOperation,
) => {
const messageDatas: Array<MessageData> = [];
const addNewMembersOperation = createAddMembersOperation(dmOperation);
if (addNewMembersOperation) {
const addNewMembersMessageData =
createAddNewMembersMessageDataFromDMOperation(addNewMembersOperation);
messageDatas.push(addNewMembersMessageData);
}

const { fieldNameToMessageData } =
createChangeSettingsMessageDatasAndUpdate(dmOperation);
messageDatas.push(...values(fieldNameToMessageData));
return { messageDatas };
},
processDMOperation: async (
dmOperation: DMChangeThreadSettingsOperation,
viewerID: string,
utilities: ProcessDMOperationUtilities,
) => {
const addMembersResult = processAddMembersOperation(
dmOperation,
viewerID,
utilities,
);

return processChangeSettingsOperation(
dmOperation,
viewerID,
utilities,
addMembersResult,
);
},		},
canBeProcessed(		canBeProcessed(
dmOperation: DMChangeThreadSettingsOperation,		dmOperation: DMChangeThreadSettingsOperation,
viewerID: string,		viewerID: string,
utilities: ProcessDMOperationUtilities,		utilities: ProcessDMOperationUtilities,
) {		) {
if (utilities.threadInfos[dmOperation.threadID]) {		if (utilities.threadInfos[dmOperation.threadID]) {
return { isProcessingPossible: true };		return { isProcessingPossible: true };
}		}
return {		return {
isProcessingPossible: false,		isProcessingPossible: false,
reason: {		reason: {
type: 'missing_thread',		type: 'missing_thread',
threadID: dmOperation.threadID,		threadID: dmOperation.threadID,
},		},
};		};
},		},
supportsAutoRetry: true,		supportsAutoRetry: true,
});		});

export {		export { changeThreadSettingsSpec, createChangeSettingsMessageDatasAndUpdate };
changeThreadSettingsSpec,
processChangeSettingsOperation,
createChangeSettingsMessageDatasAndUpdate,
};

[Services] Remove build_services compatibility logicClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 15393

services/lib/docker/build_service.sh

[Services] Remove build_services compatibility logic
ClosedPublic
Actions

Revision Contents
Changeset List