Differential D7714 Diff 26455 keyserver/src/responders/thread-responders.js

Changeset View

Standalone View

keyserver/src/responders/thread-responders.js

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

const threadDeletionRequestInputValidator = tShape({		const threadDeletionRequestInputValidator = tShape<ThreadDeletionRequest>({
threadID: tID,		threadID: tID,
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: mixed,
): Promise<LeaveThreadResult> {		): Promise<LeaveThreadResult> {
const request: ThreadDeletionRequest = input;		const request = await validateInput(
await validateInput(viewer, threadDeletionRequestInputValidator, request);		viewer,
		threadDeletionRequestInputValidator,
		input,
		);
const result = await deleteThread(viewer, request);		const result = await deleteThread(viewer, request);
return validateOutput(viewer, leaveThreadResultValidator, result);		return validateOutput(viewer, 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),
Show All 13 Lines	tShape<ChangeThreadSettingsResult>({
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 roleUpdateResponder(		async function roleUpdateResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: mixed,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: RoleChangeRequest = input;		const request = await validateInput(
await validateInput(viewer, roleChangeRequestInputValidator, request);		viewer,
		roleChangeRequestInputValidator,
		input,
		);
const result = await updateRole(viewer, request);		const result = await updateRole(viewer, request);
return validateOutput(viewer, changeThreadSettingsResultValidator, result);		return validateOutput(viewer, changeThreadSettingsResultValidator, result);
}		}

const removeMembersRequestInputValidator = tShape({		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: any,		input: mixed,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: RemoveMembersRequest = input;		const request = await validateInput(
await validateInput(viewer, removeMembersRequestInputValidator, request);		viewer,
		removeMembersRequestInputValidator,
		input,
		);
const result = await removeMembers(viewer, request);		const result = await removeMembers(viewer, request);
return validateOutput(viewer, changeThreadSettingsResultValidator, result);		return validateOutput(viewer, changeThreadSettingsResultValidator, result);
}		}

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

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

const updateThreadRequestInputValidator = tShape({		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),
color: t.maybe(tColor),		color: t.maybe(tColor),
parentThreadID: t.maybe(tID),		parentThreadID: t.maybe(tID),
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: mixed,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: UpdateThreadRequest = input;		const request = await validateInput(
await validateInput(viewer, updateThreadRequestInputValidator, request);		viewer,
		updateThreadRequestInputValidator,
		input,
		);
const result = await updateThread(viewer, request);		const result = await updateThread(viewer, request);
return validateOutput(viewer, changeThreadSettingsResultValidator, result);		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),
Show All 26 Lines	tShape<NewThreadResponse>({
newMessageInfos: t.list(rawMessageInfoValidator),		newMessageInfos: t.list(rawMessageInfoValidator),
newThreadInfo: t.maybe(rawThreadInfoValidator),		newThreadInfo: t.maybe(rawThreadInfoValidator),
userInfos: userInfosValidator,		userInfos: userInfosValidator,
newThreadID: t.maybe(tID),		newThreadID: t.maybe(tID),
});		});

async function threadCreationResponder(		async function threadCreationResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: mixed,
): Promise<NewThreadResponse> {		): Promise<NewThreadResponse> {
const request: ServerNewThreadRequest = input;		const request = await validateInput(
await validateInput(viewer, newThreadRequestInputValidator, request);		viewer,
		newThreadRequestInputValidator,
		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, newThreadResponseValidator, result);
}		}

const joinThreadRequestInputValidator = tShape({		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),
});		});

export const threadJoinResultValidator: TInterface<ThreadJoinResult> =		export const threadJoinResultValidator: TInterface<ThreadJoinResult> =
tShape<ThreadJoinResult>({		tShape<ThreadJoinResult>({
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),
}),		}),
rawMessageInfos: t.list(rawMessageInfoValidator),		rawMessageInfos: t.list(rawMessageInfoValidator),
truncationStatuses: messageTruncationStatusesValidator,		truncationStatuses: messageTruncationStatusesValidator,
userInfos: userInfosValidator,		userInfos: userInfosValidator,
rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),		rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
});		});

async function threadJoinResponder(		async function threadJoinResponder(
viewer: Viewer,		viewer: Viewer,
input: any,		input: mixed,
): Promise<ThreadJoinResult> {		): Promise<ThreadJoinResult> {
const request: ServerThreadJoinRequest = input;		const request = await validateInput(
await validateInput(viewer, joinThreadRequestInputValidator, request);		viewer,
		joinThreadRequestInputValidator,
		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, threadJoinResultValidator, result);
}		}

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

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