Differential D7685 Diff 26116 keyserver/src/responders/entry-responders.js

Changeset View

Standalone View

keyserver/src/responders/entry-responders.js

// @flow		// @flow

import t from 'tcomb';		import t from 'tcomb';
import type { TInterface } from 'tcomb';		import type { TInterface } from 'tcomb';

import { filteredThreadIDs } from 'lib/selectors/calendar-filter-selectors.js';		import { filteredThreadIDs } from 'lib/selectors/calendar-filter-selectors.js';
import type {		import {
CalendarQuery,		type CalendarQuery,
SaveEntryRequest,		type SaveEntryRequest,
CreateEntryRequest,		type CreateEntryRequest,
DeleteEntryRequest,		type DeleteEntryRequest,
DeleteEntryResponse,		type DeleteEntryResponse,
RestoreEntryRequest,		type RestoreEntryRequest,
RestoreEntryResponse,		type RestoreEntryResponse,
FetchEntryInfosResponse,		type FetchEntryInfosResponse,
DeltaEntryInfosResult,		type DeltaEntryInfosResult,
SaveEntryResponse,		type SaveEntryResponse,
		rawEntryInfoValidator,
} from 'lib/types/entry-types.js';		} from 'lib/types/entry-types.js';
import {		import {
type CalendarFilter,		type CalendarFilter,
calendarThreadFilterTypes,		calendarThreadFilterTypes,
} from 'lib/types/filter-types.js';		} from 'lib/types/filter-types.js';
import type {		import {
FetchEntryRevisionInfosResult,		type FetchEntryRevisionInfosResult,
FetchEntryRevisionInfosRequest,		type FetchEntryRevisionInfosRequest,
		historyRevisionInfoValidator,
} from 'lib/types/history-types.js';		} from 'lib/types/history-types.js';
		import { rawMessageInfoValidator } from 'lib/types/message-types.js';
		import { serverCreateUpdatesResponseValidator } from 'lib/types/update-types.js';
		import { accountUserInfoValidator } from 'lib/types/user-types.js';
import { ServerError } from 'lib/utils/errors.js';		import { ServerError } from 'lib/utils/errors.js';
import { tString, tShape, tDate } from 'lib/utils/validation-utils.js';		import { tString, tShape, tDate, tID } from 'lib/utils/validation-utils.js';

import createEntry from '../creators/entry-creator.js';		import createEntry from '../creators/entry-creator.js';
import { deleteEntry, restoreEntry } from '../deleters/entry-deleters.js';		import { deleteEntry, restoreEntry } from '../deleters/entry-deleters.js';
import {		import {
fetchEntryInfos,		fetchEntryInfos,
fetchEntryRevisionInfo,		fetchEntryRevisionInfo,
fetchEntriesForSession,		fetchEntriesForSession,
} from '../fetchers/entry-fetchers.js';		} from '../fetchers/entry-fetchers.js';
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines	): Promise<void> {
if (threadIDsToFilterTo && threadIDsToFilterTo.size > 0) {		if (threadIDsToFilterTo && threadIDsToFilterTo.size > 0) {
const verifiedThreadIDs = await verifyThreadIDs([...threadIDsToFilterTo]);		const verifiedThreadIDs = await verifyThreadIDs([...threadIDsToFilterTo]);
if (verifiedThreadIDs.length !== threadIDsToFilterTo.size) {		if (verifiedThreadIDs.length !== threadIDsToFilterTo.size) {
throw new ServerError('invalid_parameters');		throw new ServerError('invalid_parameters');
}		}
}		}
}		}

		export const fetchEntryInfosResponseValidator: TInterface<FetchEntryInfosResponse> =
		tShape<FetchEntryInfosResponse>({
		rawEntryInfos: t.list(rawEntryInfoValidator),
		userInfos: t.dict(t.String, accountUserInfoValidator),
		});

async function entryFetchResponder(		async function entryFetchResponder(
viewer: Viewer,		viewer: Viewer,
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 { ...response, userInfos: {} };
}		}

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

		export const fetchEntryRevisionInfosResultValidator: TInterface<FetchEntryRevisionInfosResult> =
		tShape<FetchEntryRevisionInfosResult>({
		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 };		return { result: entryHistory };
}		}

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,
localID: t.maybe(t.String),		localID: t.maybe(t.String),
calendarQuery: t.maybe(newEntryQueryInputValidator),		calendarQuery: t.maybe(newEntryQueryInputValidator),
});		});

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

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);		return await createEntry(viewer, request);
}		}
Show All 19 Lines
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> =
		tShape<DeleteEntryResponse>({
		newMessageInfos: t.list(rawMessageInfoValidator),
		threadID: tID,
		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);		return await deleteEntry(viewer, request);
}		}

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> =
		tShape<RestoreEntryResponse>({
		newMessageInfos: t.list(rawMessageInfoValidator),
		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);		return await restoreEntry(viewer, request);
}		}

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

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

await verifyCalendarQueryThreadIDs(request);		await verifyCalendarQueryThreadIDs(request);
Show All 33 Lines