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

Changeset View

Standalone View

keyserver/src/responders/entry-responders.js

	Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
	export const fetchEntryInfosResponseValidator: TInterface<FetchEntryInfosResponse> =			export const fetchEntryInfosResponseValidator: TInterface<FetchEntryInfosResponse> =
	tShape<FetchEntryInfosResponse>({			tShape<FetchEntryInfosResponse>({
	rawEntryInfos: t.list(rawEntryInfoValidator),			rawEntryInfos: t.list(rawEntryInfoValidator),
	userInfos: t.dict(t.String, accountUserInfoValidator),			userInfos: t.dict(t.String, accountUserInfoValidator),
	});			});

	async function entryFetchResponder(			async function entryFetchResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<FetchEntryInfosResponse> {			): Promise<FetchEntryInfosResponse> {
	await validateInput(viewer, entryQueryInputValidator, input);			const inputQuery = await validateInput(
	const request = normalizeCalendarQuery(input);			viewer,
				entryQueryInputValidator,
				input,
				);
				const request = normalizeCalendarQuery(inputQuery);

	await verifyCalendarQueryThreadIDs(request);			await verifyCalendarQueryThreadIDs(request);

	const response = await fetchEntryInfos(viewer, [request]);			const response = await fetchEntryInfos(viewer, [request]);
	return validateOutput(viewer, fetchEntryInfosResponseValidator, {			return validateOutput(viewer, fetchEntryInfosResponseValidator, {
	...response,			...response,
	userInfos: {},			userInfos: {},
	});			});
	}			}

	const entryRevisionHistoryFetchInputValidator = tShape({			const entryRevisionHistoryFetchInputValidator =
				tShape<FetchEntryRevisionInfosRequest>({
	id: tID,			id: tID,
	});			});

	export const fetchEntryRevisionInfosResultValidator: TInterface<FetchEntryRevisionInfosResult> =			export const fetchEntryRevisionInfosResultValidator: TInterface<FetchEntryRevisionInfosResult> =
	tShape<FetchEntryRevisionInfosResult>({			tShape<FetchEntryRevisionInfosResult>({
	result: t.list(historyRevisionInfoValidator),			result: t.list(historyRevisionInfoValidator),
	});			});

	async function entryRevisionFetchResponder(			async function entryRevisionFetchResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<FetchEntryRevisionInfosResult> {			): Promise<FetchEntryRevisionInfosResult> {
	const request: FetchEntryRevisionInfosRequest = input;			const request = await validateInput(
	await validateInput(viewer, entryRevisionHistoryFetchInputValidator, request);			viewer,
				entryRevisionHistoryFetchInputValidator,
				input,
				);
	const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);			const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);
	const response = { result: entryHistory };			const response = { result: entryHistory };
	return validateOutput(			return validateOutput(
	viewer,			viewer,
	fetchEntryRevisionInfosResultValidator,			fetchEntryRevisionInfosResultValidator,
	response,			response,
	);			);
	}			}

	const createEntryRequestInputValidator = tShape({			const createEntryRequestInputValidator = tShape<CreateEntryRequest>({
	text: t.String,			text: t.String,
	sessionID: t.maybe(t.String),			sessionID: t.maybe(t.String),
	timestamp: t.Number,			timestamp: t.Number,
	date: tDate,			date: tDate,
	threadID: tID,			threadID: tID,
	localID: t.maybe(t.String),			localID: t.maybe(t.String),
	calendarQuery: t.maybe(newEntryQueryInputValidator),			calendarQuery: t.maybe(newEntryQueryInputValidator),
	});			});

	export const saveEntryResponseValidator: TInterface<SaveEntryResponse> =			export const saveEntryResponseValidator: TInterface<SaveEntryResponse> =
	tShape<SaveEntryResponse>({			tShape<SaveEntryResponse>({
	entryID: tID,			entryID: tID,
	newMessageInfos: t.list(rawMessageInfoValidator),			newMessageInfos: t.list(rawMessageInfoValidator),
	updatesResult: serverCreateUpdatesResponseValidator,			updatesResult: serverCreateUpdatesResponseValidator,
	});			});

	async function entryCreationResponder(			async function entryCreationResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<SaveEntryResponse> {			): Promise<SaveEntryResponse> {
	const request: CreateEntryRequest = input;			const request = await validateInput(
	await validateInput(viewer, createEntryRequestInputValidator, request);			viewer,
				createEntryRequestInputValidator,
				input,
				);
	const response = await createEntry(viewer, request);			const response = await createEntry(viewer, request);
	return validateOutput(viewer, saveEntryResponseValidator, response);			return validateOutput(viewer, saveEntryResponseValidator, response);
	}			}

	const saveEntryRequestInputValidator = tShape({			const saveEntryRequestInputValidator = tShape<SaveEntryRequest>({
	entryID: tID,			entryID: tID,
	text: t.String,			text: t.String,
	prevText: t.String,			prevText: t.String,
	sessionID: t.maybe(t.String),			sessionID: t.maybe(t.String),
	timestamp: t.Number,			timestamp: t.Number,
	calendarQuery: t.maybe(newEntryQueryInputValidator),			calendarQuery: t.maybe(newEntryQueryInputValidator),
	});			});

	async function entryUpdateResponder(			async function entryUpdateResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<SaveEntryResponse> {			): Promise<SaveEntryResponse> {
	const request: SaveEntryRequest = input;			const request = await validateInput(
	await validateInput(viewer, saveEntryRequestInputValidator, request);			viewer,
				saveEntryRequestInputValidator,
				input,
				);
	const response = await updateEntry(viewer, request);			const response = await updateEntry(viewer, request);
	return validateOutput(viewer, saveEntryResponseValidator, response);			return validateOutput(viewer, saveEntryResponseValidator, response);
	}			}

	const deleteEntryRequestInputValidator = tShape({			const deleteEntryRequestInputValidator = tShape<DeleteEntryRequest>({
	entryID: tID,			entryID: tID,
	prevText: t.String,			prevText: t.String,
	sessionID: t.maybe(t.String),			sessionID: t.maybe(t.String),
	timestamp: t.Number,			timestamp: t.Number,
	calendarQuery: t.maybe(newEntryQueryInputValidator),			calendarQuery: t.maybe(newEntryQueryInputValidator),
	});			});

	export const deleteEntryResponseValidator: TInterface<DeleteEntryResponse> =			export const deleteEntryResponseValidator: TInterface<DeleteEntryResponse> =
	tShape<DeleteEntryResponse>({			tShape<DeleteEntryResponse>({
	newMessageInfos: t.list(rawMessageInfoValidator),			newMessageInfos: t.list(rawMessageInfoValidator),
	threadID: tID,			threadID: tID,
	updatesResult: serverCreateUpdatesResponseValidator,			updatesResult: serverCreateUpdatesResponseValidator,
	});			});

	async function entryDeletionResponder(			async function entryDeletionResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<DeleteEntryResponse> {			): Promise<DeleteEntryResponse> {
	const request: DeleteEntryRequest = input;			const request = await validateInput(
	await validateInput(viewer, deleteEntryRequestInputValidator, request);			viewer,
				deleteEntryRequestInputValidator,
				input,
				);
	const response = await deleteEntry(viewer, request);			const response = await deleteEntry(viewer, request);
	return validateOutput(viewer, deleteEntryResponseValidator, response);			return validateOutput(viewer, deleteEntryResponseValidator, response);
	}			}

	const restoreEntryRequestInputValidator = tShape({			const restoreEntryRequestInputValidator = tShape<RestoreEntryRequest>({
	entryID: tID,			entryID: tID,
	sessionID: t.maybe(t.String),			sessionID: t.maybe(t.String),
	timestamp: t.Number,			timestamp: t.Number,
	calendarQuery: t.maybe(newEntryQueryInputValidator),			calendarQuery: t.maybe(newEntryQueryInputValidator),
	});			});

	export const restoreEntryResponseValidator: TInterface<RestoreEntryResponse> =			export const restoreEntryResponseValidator: TInterface<RestoreEntryResponse> =
	tShape<RestoreEntryResponse>({			tShape<RestoreEntryResponse>({
	newMessageInfos: t.list(rawMessageInfoValidator),			newMessageInfos: t.list(rawMessageInfoValidator),
	updatesResult: serverCreateUpdatesResponseValidator,			updatesResult: serverCreateUpdatesResponseValidator,
	});			});

	async function entryRestorationResponder(			async function entryRestorationResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<RestoreEntryResponse> {			): Promise<RestoreEntryResponse> {
	const request: RestoreEntryRequest = input;			const request = await validateInput(
	await validateInput(viewer, restoreEntryRequestInputValidator, request);			viewer,
				restoreEntryRequestInputValidator,
				input,
				);
	const response = await restoreEntry(viewer, request);			const response = await restoreEntry(viewer, request);
	return validateOutput(viewer, restoreEntryResponseValidator, response);			return validateOutput(viewer, restoreEntryResponseValidator, response);
	}			}

	export const deltaEntryInfosResultValidator: TInterface<DeltaEntryInfosResult> =			export const deltaEntryInfosResultValidator: TInterface<DeltaEntryInfosResult> =
	tShape<DeltaEntryInfosResult>({			tShape<DeltaEntryInfosResult>({
	rawEntryInfos: t.list(rawEntryInfoValidator),			rawEntryInfos: t.list(rawEntryInfoValidator),
	deletedEntryIDs: t.list(tID),			deletedEntryIDs: t.list(tID),
	userInfos: t.list(accountUserInfoValidator),			userInfos: t.list(accountUserInfoValidator),
	});			});

	async function calendarQueryUpdateResponder(			async function calendarQueryUpdateResponder(
	viewer: Viewer,			viewer: Viewer,
	input: any,			input: mixed,
	): Promise<DeltaEntryInfosResult> {			): Promise<DeltaEntryInfosResult> {
	const request: CalendarQuery = input;			const request = await validateInput(
	await validateInput(viewer, newEntryQueryInputValidator, input);			viewer,
				newEntryQueryInputValidator,
				input,
				);

	await verifyCalendarQueryThreadIDs(request);			await verifyCalendarQueryThreadIDs(request);
	if (!viewer.loggedIn) {			if (!viewer.loggedIn) {
	throw new ServerError('not_logged_in');			throw new ServerError('not_logged_in');
	}			}

	const { difference, oldCalendarQuery, sessionUpdate } =			const { difference, oldCalendarQuery, sessionUpdate } =
	compareNewCalendarQuery(viewer, request);			compareNewCalendarQuery(viewer, request);
	Show All 27 Lines