Differential D7713 Diff 26453 keyserver/src/responders/thread-responders.js

Changeset View

Standalone View

keyserver/src/responders/thread-responders.js

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines	import {
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({
threadID: t.String,		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: any,
): Promise<LeaveThreadResult> {		): Promise<LeaveThreadResult> {
const request: ThreadDeletionRequest = input;		const request: ThreadDeletionRequest = input;
await validateInput(viewer, threadDeletionRequestInputValidator, request);		await validateInput(viewer, threadDeletionRequestInputValidator, request);
const result = await deleteThread(viewer, request);		const result = await deleteThread(viewer, request);
return validateOutput(viewer, leaveThreadResultValidator, result);		return validateOutput(viewer, leaveThreadResultValidator, result);
}		}

const roleChangeRequestInputValidator = tShape({		export const roleChangeRequestInputValidator: TInterface<RoleChangeRequest> =
threadID: t.String,		tShape<RoleChangeRequest>({
		threadID: tID,
memberIDs: t.list(t.String),		memberIDs: t.list(t.String),
role: t.refinement(t.String, str => {		role: t.refinement(tID, str => {
		if (str.indexOf('\|') !== -1) {
		str = str.split('\|')[1];
		}
const int = parseInt(str, 10);		const int = parseInt(str, 10);
return String(int) === str && int > 0;		return String(int) === str && int > 0;
}),		}),
});		});

export const changeThreadSettingsResultValidator: TInterface<ChangeThreadSettingsResult> =		export const changeThreadSettingsResultValidator: TInterface<ChangeThreadSettingsResult> =
tShape<ChangeThreadSettingsResult>({		tShape<ChangeThreadSettingsResult>({
newMessageInfos: t.list(rawMessageInfoValidator),		newMessageInfos: t.list(rawMessageInfoValidator),
threadInfo: t.maybe(rawThreadInfoValidator),		threadInfo: t.maybe(rawThreadInfoValidator),
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: any,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: RoleChangeRequest = input;		const request: RoleChangeRequest = input;
await validateInput(viewer, roleChangeRequestInputValidator, request);		await validateInput(viewer, roleChangeRequestInputValidator, request);
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({
threadID: t.String,		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: any,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: RemoveMembersRequest = input;		const request: RemoveMembersRequest = input;
await validateInput(viewer, removeMembersRequestInputValidator, request);		await validateInput(viewer, removeMembersRequestInputValidator, request);
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({
threadID: t.String,		threadID: tID,
});		});

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);
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({
threadID: t.String,		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(t.String),		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: any,
): Promise<ChangeThreadSettingsResult> {		): Promise<ChangeThreadSettingsResult> {
const request: UpdateThreadRequest = input;		const request: UpdateThreadRequest = input;
await validateInput(viewer, updateThreadRequestInputValidator, request);		await validateInput(viewer, updateThreadRequestInputValidator, request);
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),
parentThreadID: t.maybe(t.String),		parentThreadID: t.maybe(tID),
initialMemberIDs: t.maybe(t.list(t.String)),		initialMemberIDs: t.maybe(t.list(t.String)),
calendarQuery: t.maybe(entryQueryInputValidator),		calendarQuery: t.maybe(entryQueryInputValidator),
};		};
const newThreadRequestInputValidator: TUnion<ServerNewThreadRequest> = t.union([		const newThreadRequestInputValidator: TUnion<ServerNewThreadRequest> = t.union([
tShape({		tShape({
type: tNumEnum([threadTypes.SIDEBAR]),		type: tNumEnum([threadTypes.SIDEBAR]),
sourceMessageID: t.String,		sourceMessageID: tID,
...threadRequestValidationShape,		...threadRequestValidationShape,
}),		}),
tShape({		tShape({
type: tNumEnum([		type: tNumEnum([
threadTypes.COMMUNITY_OPEN_SUBTHREAD,		threadTypes.COMMUNITY_OPEN_SUBTHREAD,
threadTypes.COMMUNITY_SECRET_SUBTHREAD,		threadTypes.COMMUNITY_SECRET_SUBTHREAD,
threadTypes.PERSONAL,		threadTypes.PERSONAL,
threadTypes.LOCAL,		threadTypes.LOCAL,
Show All 22 Lines	): Promise<NewThreadResponse> {

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({
threadID: t.String,		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({
Show All 16 Lines	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({
threadID: t.String,		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: any,
): Promise<ThreadFetchMediaResult> {		): Promise<ThreadFetchMediaResult> {
const request: ThreadFetchMediaRequest = input;		const request: ThreadFetchMediaRequest = input;
await validateInput(viewer, threadFetchMediaRequestInputValidator, request);		await validateInput(viewer, threadFetchMediaRequestInputValidator, request);
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({
messageID: t.String,		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,
});		});
Show All 23 Lines