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

Changeset View

Standalone View

keyserver/src/responders/entry-responders.js

Show All 40 Lines
} from '../fetchers/entry-fetchers.js';		} from '../fetchers/entry-fetchers.js';
import { verifyThreadIDs } from '../fetchers/thread-fetchers.js';		import { verifyThreadIDs } from '../fetchers/thread-fetchers.js';
import type { Viewer } from '../session/viewer.js';		import type { Viewer } from '../session/viewer.js';
import {		import {
updateEntry,		updateEntry,
compareNewCalendarQuery,		compareNewCalendarQuery,
} from '../updaters/entry-updaters.js';		} from '../updaters/entry-updaters.js';
import { commitSessionUpdate } from '../updaters/session-updaters.js';		import { commitSessionUpdate } from '../updaters/session-updaters.js';
import { validateInput } from '../utils/validation-utils.js';		import { validateInput, validateOutput } from '../utils/validation-utils.js';

type EntryQueryInput = {		type EntryQueryInput = {
+startDate: string,		+startDate: string,
+endDate: string,		+endDate: string,
+navID?: ?string,		+navID?: ?string,
+includeDeleted?: ?boolean,		+includeDeleted?: ?boolean,
+filters?: ?$ReadOnlyArray<CalendarFilter>,		+filters?: ?$ReadOnlyArray<CalendarFilter>,
};		};
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines	async function entryFetchResponder(
input: any,		input: any,
): Promise<FetchEntryInfosResponse> {		): Promise<FetchEntryInfosResponse> {
await validateInput(viewer, entryQueryInputValidator, input);		await validateInput(viewer, entryQueryInputValidator, input);
const request = normalizeCalendarQuery(input);		const request = normalizeCalendarQuery(input);

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

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

const entryRevisionHistoryFetchInputValidator = tShape({		const entryRevisionHistoryFetchInputValidator = tShape({
id: t.String,		id: t.String,
});		});

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: any,
): Promise<FetchEntryRevisionInfosResult> {		): Promise<FetchEntryRevisionInfosResult> {
const request: FetchEntryRevisionInfosRequest = input;		const request: FetchEntryRevisionInfosRequest = input;
await validateInput(viewer, entryRevisionHistoryFetchInputValidator, request);		await validateInput(viewer, entryRevisionHistoryFetchInputValidator, request);
const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);		const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);
return { result: entryHistory };		const response = { result: entryHistory };
		return validateOutput(
		viewer,
		fetchEntryRevisionInfosResultValidator,
		response,
		);
}		}

const createEntryRequestInputValidator = tShape({		const createEntryRequestInputValidator = tShape({
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: t.String,		threadID: t.String,
Show All 9 Lines	export const saveEntryResponseValidator: TInterface<SaveEntryResponse> =
});		});

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

const saveEntryRequestInputValidator = tShape({		const saveEntryRequestInputValidator = tShape({
entryID: t.String,		entryID: t.String,
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: any,
): Promise<SaveEntryResponse> {		): Promise<SaveEntryResponse> {
const request: SaveEntryRequest = input;		const request: SaveEntryRequest = input;
await validateInput(viewer, saveEntryRequestInputValidator, request);		await validateInput(viewer, saveEntryRequestInputValidator, request);
return await updateEntry(viewer, request);		const response = await updateEntry(viewer, request);
		return validateOutput(viewer, saveEntryResponseValidator, response);
}		}

const deleteEntryRequestInputValidator = tShape({		const deleteEntryRequestInputValidator = tShape({
entryID: t.String,		entryID: 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),
});		});

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: any,
): Promise<DeleteEntryResponse> {		): Promise<DeleteEntryResponse> {
const request: DeleteEntryRequest = input;		const request: DeleteEntryRequest = input;
await validateInput(viewer, deleteEntryRequestInputValidator, request);		await validateInput(viewer, deleteEntryRequestInputValidator, request);
return await deleteEntry(viewer, request);		const response = await deleteEntry(viewer, request);
		return validateOutput(viewer, deleteEntryResponseValidator, response);
}		}

const restoreEntryRequestInputValidator = tShape({		const restoreEntryRequestInputValidator = tShape({
entryID: t.String,		entryID: 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 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: any,
): Promise<RestoreEntryResponse> {		): Promise<RestoreEntryResponse> {
const request: RestoreEntryRequest = input;		const request: RestoreEntryRequest = input;
await validateInput(viewer, restoreEntryRequestInputValidator, request);		await validateInput(viewer, restoreEntryRequestInputValidator, request);
return await restoreEntry(viewer, request);		const response = await restoreEntry(viewer, request);
		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),
});		});
Show All 13 Lines	): Promise<DeltaEntryInfosResult> {
const { difference, oldCalendarQuery, sessionUpdate } =		const { difference, oldCalendarQuery, sessionUpdate } =
compareNewCalendarQuery(viewer, request);		compareNewCalendarQuery(viewer, request);

const [response] = await Promise.all([		const [response] = await Promise.all([
fetchEntriesForSession(viewer, difference, oldCalendarQuery),		fetchEntriesForSession(viewer, difference, oldCalendarQuery),
commitSessionUpdate(viewer, sessionUpdate),		commitSessionUpdate(viewer, sessionUpdate),
]);		]);

return {		return validateOutput(viewer, deltaEntryInfosResultValidator, {
rawEntryInfos: response.rawEntryInfos,		rawEntryInfos: response.rawEntryInfos,
deletedEntryIDs: response.deletedEntryIDs,		deletedEntryIDs: response.deletedEntryIDs,
// Old clients expect userInfos object		// Old clients expect userInfos object
userInfos: [],		userInfos: [],
};		});
}		}

export {		export {
entryQueryInputValidator,		entryQueryInputValidator,
newEntryQueryInputValidator,		newEntryQueryInputValidator,
normalizeCalendarQuery,		normalizeCalendarQuery,
verifyCalendarQueryThreadIDs,		verifyCalendarQueryThreadIDs,
entryFetchResponder,		entryFetchResponder,
entryRevisionFetchResponder,		entryRevisionFetchResponder,
entryCreationResponder,		entryCreationResponder,
entryUpdateResponder,		entryUpdateResponder,
entryDeletionResponder,		entryDeletionResponder,
entryRestorationResponder,		entryRestorationResponder,
calendarQueryUpdateResponder,		calendarQueryUpdateResponder,
};		};