Differential D7712 Diff 26451 keyserver/src/responders/thread-responders.js

Changeset View

Standalone View

keyserver/src/responders/thread-responders.js

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
import {		import {
updateRole,		updateRole,
removeMembers,		removeMembers,
leaveThread,		leaveThread,
updateThread,		updateThread,
joinThread,		joinThread,
toggleMessagePinForThread,		toggleMessagePinForThread,
} from '../updaters/thread-updaters.js';		} from '../updaters/thread-updaters.js';
import { validateInput } from '../utils/validation-utils.js';		import { validateInput, validateOutput } from '../utils/validation-utils.js';

const threadDeletionRequestInputValidator = tShape({		const threadDeletionRequestInputValidator = tShape({
threadID: t.String,		threadID: t.String,
accountPassword: t.maybe(tPassword),		accountPassword: t.maybe(tPassword),
});		});

export const leaveThreadResultValidator: TInterface<LeaveThreadResult> =		export const leaveThreadResultValidator: TInterface<LeaveThreadResult> =
tShape<LeaveThreadResult>({		tShape<LeaveThreadResult>({
threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),		threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
updatesResult: tShape({		updatesResult: tShape({
newUpdates: t.list(serverUpdateInfoValidator),		newUpdates: t.list(serverUpdateInfoValidator),
}),		}),
});		});

async function threadDeletionResponder(		async function threadDeletionResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: any,
): Promise<LeaveThreadResult> {		): Promise<LeaveThreadResult> {
const request: ThreadDeletionRequest = input;		const request: ThreadDeletionRequest = input;
await validateInput(viewer, threadDeletionRequestInputValidator, request);		await validateInput(viewer, threadDeletionRequestInputValidator, request);
return await deleteThread(viewer, request);		const result = await deleteThread(viewer, request);
		return validateOutput(viewer, leaveThreadResultValidator, result);
}		}

const roleChangeRequestInputValidator = tShape({		const roleChangeRequestInputValidator = tShape({
threadID: t.String,		threadID: t.String,
memberIDs: t.list(t.String),		memberIDs: t.list(t.String),
role: t.refinement(t.String, str => {		role: t.refinement(t.String, str => {
const int = parseInt(str, 10);		const int = parseInt(str, 10);
return String(int) === str && int > 0;		return String(int) === str && int > 0;
Show All 11 Lines	export const changeThreadSettingsResultValidator: TInterface<ChangeThreadSettingsResult> =
});		});

async function roleUpdateResponder(		async function roleUpdateResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: any,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: RoleChangeRequest = input;		const request: RoleChangeRequest = input;
await validateInput(viewer, roleChangeRequestInputValidator, request);		await validateInput(viewer, roleChangeRequestInputValidator, request);
return await updateRole(viewer, request);		const result = await updateRole(viewer, request);
		return validateOutput(viewer, changeThreadSettingsResultValidator, result);
}		}

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

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

const leaveThreadRequestInputValidator = tShape({		const leaveThreadRequestInputValidator = tShape({
threadID: t.String,		threadID: t.String,
});		});

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

const updateThreadRequestInputValidator = tShape({		const updateThreadRequestInputValidator = tShape({
threadID: t.String,		threadID: t.String,
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),
color: t.maybe(tColor),		color: t.maybe(tColor),
parentThreadID: t.maybe(t.String),		parentThreadID: t.maybe(t.String),
newMemberIDs: t.maybe(t.list(t.String)),		newMemberIDs: t.maybe(t.list(t.String)),
avatar: t.maybe(updateUserAvatarRequestValidator),		avatar: t.maybe(updateUserAvatarRequestValidator),
}),		}),
accountPassword: t.maybe(tPassword),		accountPassword: t.maybe(tPassword),
});		});

async function threadUpdateResponder(		async function threadUpdateResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: any,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: UpdateThreadRequest = input;		const request: UpdateThreadRequest = input;
await validateInput(viewer, updateThreadRequestInputValidator, request);		await validateInput(viewer, updateThreadRequestInputValidator, request);
return await updateThread(viewer, request);		const result = await updateThread(viewer, request);
		return validateOutput(viewer, 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(t.String),		parentThreadID: t.maybe(t.String),
initialMemberIDs: t.maybe(t.list(t.String)),		initialMemberIDs: t.maybe(t.list(t.String)),
Show All 29 Lines

async function threadCreationResponder(		async function threadCreationResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: any,
): Promise<NewThreadResponse> {		): Promise<NewThreadResponse> {
const request: ServerNewThreadRequest = input;		const request: ServerNewThreadRequest = input;
await validateInput(viewer, newThreadRequestInputValidator, request);		await validateInput(viewer, newThreadRequestInputValidator, request);

return 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);
}		}

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

Show All 15 Lines
): Promise<ThreadJoinResult> {		): Promise<ThreadJoinResult> {
const request: ServerThreadJoinRequest = input;		const request: ServerThreadJoinRequest = input;
await validateInput(viewer, joinThreadRequestInputValidator, request);		await validateInput(viewer, joinThreadRequestInputValidator, request);

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

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

const threadFetchMediaRequestInputValidator = tShape({		const threadFetchMediaRequestInputValidator = tShape({
threadID: t.String,		threadID: t.String,
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: any,		input: any,
): Promise<ThreadFetchMediaResult> {		): Promise<ThreadFetchMediaResult> {
const request: ThreadFetchMediaRequest = input;		const request: ThreadFetchMediaRequest = input;
await validateInput(viewer, threadFetchMediaRequestInputValidator, request);		await validateInput(viewer, threadFetchMediaRequestInputValidator, request);
return await fetchMediaForThread(viewer, request);		const result = await fetchMediaForThread(viewer, request);
		return validateOutput(viewer, threadFetchMediaResultValidator, result);
}		}

const toggleMessagePinRequestInputValidator = tShape({		const toggleMessagePinRequestInputValidator = tShape({
messageID: t.String,		messageID: t.String,
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: any,		input: any,
): Promise<ToggleMessagePinResult> {		): Promise<ToggleMessagePinResult> {
const request: ToggleMessagePinRequest = input;		const request: ToggleMessagePinRequest = input;
await validateInput(viewer, toggleMessagePinRequestInputValidator, request);		await validateInput(viewer, toggleMessagePinRequestInputValidator, request);
return await toggleMessagePinForThread(viewer, request);		const result = await toggleMessagePinForThread(viewer, request);
		return validateOutput(viewer, toggleMessagePinResultValidator, result);
}		}

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