Differential D7805 Diff 26571 keyserver/src/responders/thread-responders.js

Changeset View

Standalone View

keyserver/src/responders/thread-responders.js

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines	async function threadDeletionResponder(
input: mixed,		input: mixed,
): Promise<LeaveThreadResult> {		): Promise<LeaveThreadResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
threadDeletionRequestInputValidator,		threadDeletionRequestInputValidator,
input,		input,
);		);
const result = await deleteThread(viewer, request);		const result = await deleteThread(viewer, request);
return validateOutput(viewer, leaveThreadResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		leaveThreadResultValidator,
		result,
		);
}		}

export const roleChangeRequestInputValidator: TInterface<RoleChangeRequest> =		export const roleChangeRequestInputValidator: TInterface<RoleChangeRequest> =
tShape<RoleChangeRequest>({		tShape<RoleChangeRequest>({
threadID: tID,		threadID: tID,
memberIDs: t.list(t.String),		memberIDs: t.list(t.String),
role: t.refinement(tID, str => {		role: t.refinement(tID, str => {
if (str.indexOf('\|') !== -1) {		if (str.indexOf('\|') !== -1) {
Show All 19 Lines	async function roleUpdateResponder(
input: mixed,		input: mixed,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
roleChangeRequestInputValidator,		roleChangeRequestInputValidator,
input,		input,
);		);
const result = await updateRole(viewer, request);		const result = await updateRole(viewer, request);
return validateOutput(viewer, changeThreadSettingsResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		changeThreadSettingsResultValidator,
		result,
		);
}		}

const removeMembersRequestInputValidator = tShape<RemoveMembersRequest>({		const removeMembersRequestInputValidator = tShape<RemoveMembersRequest>({
threadID: tID,		threadID: tID,
memberIDs: t.list(t.String),		memberIDs: t.list(t.String),
});		});

async function memberRemovalResponder(		async function memberRemovalResponder(
viewer: Viewer,		viewer: Viewer,
input: mixed,		input: mixed,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
removeMembersRequestInputValidator,		removeMembersRequestInputValidator,
input,		input,
);		);
const result = await removeMembers(viewer, request);		const result = await removeMembers(viewer, request);
return validateOutput(viewer, changeThreadSettingsResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		changeThreadSettingsResultValidator,
		result,
		);
}		}

const leaveThreadRequestInputValidator = tShape<LeaveThreadRequest>({		const leaveThreadRequestInputValidator = tShape<LeaveThreadRequest>({
threadID: tID,		threadID: tID,
});		});

async function threadLeaveResponder(		async function threadLeaveResponder(
viewer: Viewer,		viewer: Viewer,
input: mixed,		input: mixed,
): Promise<LeaveThreadResult> {		): Promise<LeaveThreadResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
leaveThreadRequestInputValidator,		leaveThreadRequestInputValidator,
input,		input,
);		);
const result = await leaveThread(viewer, request);		const result = await leaveThread(viewer, request);
return validateOutput(viewer, leaveThreadResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		leaveThreadResultValidator,
		result,
		);
}		}

const updateThreadRequestInputValidator = tShape<UpdateThreadRequest>({		const updateThreadRequestInputValidator = tShape<UpdateThreadRequest>({
threadID: tID,		threadID: tID,
changes: tShape({		changes: tShape({
type: t.maybe(tNumEnum(values(threadTypes))),		type: t.maybe(tNumEnum(values(threadTypes))),
name: t.maybe(t.String),		name: t.maybe(t.String),
description: t.maybe(t.String),		description: t.maybe(t.String),
Show All 10 Lines	async function threadUpdateResponder(
input: mixed,		input: mixed,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
updateThreadRequestInputValidator,		updateThreadRequestInputValidator,
input,		input,
);		);
const result = await updateThread(viewer, request);		const result = await updateThread(viewer, request);
return validateOutput(viewer, changeThreadSettingsResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		changeThreadSettingsResultValidator,
		result,
		);
}		}

const threadRequestValidationShape = {		const threadRequestValidationShape = {
name: t.maybe(t.String),		name: t.maybe(t.String),
description: t.maybe(t.String),		description: t.maybe(t.String),
color: t.maybe(tColor),		color: t.maybe(tColor),
parentThreadID: t.maybe(tID),		parentThreadID: t.maybe(tID),
initialMemberIDs: t.maybe(t.list(t.String)),		initialMemberIDs: t.maybe(t.list(t.String)),
Show All 37 Lines	const request = await validateInput(
viewer,		viewer,
newThreadRequestInputValidator,		newThreadRequestInputValidator,
input,		input,
);		);

const result = await createThread(viewer, request, {		const result = await createThread(viewer, request, {
silentlyFailMembers: request.type === threadTypes.SIDEBAR,		silentlyFailMembers: request.type === threadTypes.SIDEBAR,
});		});
return validateOutput(viewer, newThreadResponseValidator, result);		return validateOutput(
		viewer.platformDetails,
		newThreadResponseValidator,
		result,
		);
}		}

const joinThreadRequestInputValidator = tShape<ServerThreadJoinRequest>({		const joinThreadRequestInputValidator = tShape<ServerThreadJoinRequest>({
threadID: tID,		threadID: tID,
calendarQuery: t.maybe(entryQueryInputValidator),		calendarQuery: t.maybe(entryQueryInputValidator),
inviteLinkSecret: t.maybe(t.String),		inviteLinkSecret: t.maybe(t.String),
});		});

Show All 19 Lines	const request = await validateInput(
input,		input,
);		);

if (request.calendarQuery) {		if (request.calendarQuery) {
await verifyCalendarQueryThreadIDs(request.calendarQuery);		await verifyCalendarQueryThreadIDs(request.calendarQuery);
}		}

const result = await joinThread(viewer, request);		const result = await joinThread(viewer, request);
return validateOutput(viewer, threadJoinResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		threadJoinResultValidator,
		result,
		);
}		}

const threadFetchMediaRequestInputValidator = tShape<ThreadFetchMediaRequest>({		const threadFetchMediaRequestInputValidator = tShape<ThreadFetchMediaRequest>({
threadID: tID,		threadID: tID,
limit: t.Number,		limit: t.Number,
offset: t.Number,		offset: t.Number,
});		});

export const threadFetchMediaResultValidator: TInterface<ThreadFetchMediaResult> =		export const threadFetchMediaResultValidator: TInterface<ThreadFetchMediaResult> =
tShape<ThreadFetchMediaResult>({ media: t.list(mediaValidator) });		tShape<ThreadFetchMediaResult>({ media: t.list(mediaValidator) });

async function threadFetchMediaResponder(		async function threadFetchMediaResponder(
viewer: Viewer,		viewer: Viewer,
input: mixed,		input: mixed,
): Promise<ThreadFetchMediaResult> {		): Promise<ThreadFetchMediaResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
threadFetchMediaRequestInputValidator,		threadFetchMediaRequestInputValidator,
input,		input,
);		);
const result = await fetchMediaForThread(viewer, request);		const result = await fetchMediaForThread(viewer, request);
return validateOutput(viewer, threadFetchMediaResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		threadFetchMediaResultValidator,
		result,
		);
}		}

const toggleMessagePinRequestInputValidator = tShape<ToggleMessagePinRequest>({		const toggleMessagePinRequestInputValidator = tShape<ToggleMessagePinRequest>({
messageID: tID,		messageID: tID,
action: t.enums.of(['pin', 'unpin']),		action: t.enums.of(['pin', 'unpin']),
});		});

export const toggleMessagePinResultValidator: TInterface<ToggleMessagePinResult> =		export const toggleMessagePinResultValidator: TInterface<ToggleMessagePinResult> =
tShape<ToggleMessagePinResult>({		tShape<ToggleMessagePinResult>({
newMessageInfos: t.list(rawMessageInfoValidator),		newMessageInfos: t.list(rawMessageInfoValidator),
threadID: tID,		threadID: tID,
});		});

async function toggleMessagePinResponder(		async function toggleMessagePinResponder(
viewer: Viewer,		viewer: Viewer,
input: mixed,		input: mixed,
): Promise<ToggleMessagePinResult> {		): Promise<ToggleMessagePinResult> {
const request = await validateInput(		const request = await validateInput(
viewer,		viewer,
toggleMessagePinRequestInputValidator,		toggleMessagePinRequestInputValidator,
input,		input,
);		);
const result = await toggleMessagePinForThread(viewer, request);		const result = await toggleMessagePinForThread(viewer, request);
return validateOutput(viewer, toggleMessagePinResultValidator, result);		return validateOutput(
		viewer.platformDetails,
		toggleMessagePinResultValidator,
		result,
		);
}		}

export {		export {
threadDeletionResponder,		threadDeletionResponder,
roleUpdateResponder,		roleUpdateResponder,
memberRemovalResponder,		memberRemovalResponder,
threadLeaveResponder,		threadLeaveResponder,
threadUpdateResponder,		threadUpdateResponder,
threadCreationResponder,		threadCreationResponder,
threadJoinResponder,		threadJoinResponder,
threadFetchMediaResponder,		threadFetchMediaResponder,
newThreadRequestInputValidator,		newThreadRequestInputValidator,
toggleMessagePinResponder,		toggleMessagePinResponder,
};		};