@fc3/mmcadi 0.1.0

package/src/server/endpoint/action/get.ts

@@ -0,0 +1,231 @@
+import {ContentType, HttpMethod} from 'lib/http';
+import {InvariantViolation, InvalidError} from 'lib/errors';
+
+import BaseEndpoint from 'server/endpoint/base';
+import BlockType from 'enum/block-type';
+import ActionResultSerializer from 'server/result-serializer/action';
+import getParentPath from 'common/utility/get-parent-path';
+import getBlockPermissions from 'server/utility/get-block-permissions';
+import getPathForFolderBlock from 'server/utility/get-path-for-folder-block';
+import FolderBlock from 'type/block/folder';
+import PermissionType from 'enum/permission-type';
+import Color from 'enum/color';
+import Emoji from 'enum/emoji';
+import LoadPageOperation from 'server/operation/load-page';
+import Block from 'type/block';
+import validatePath from 'server/utility/validate-path';
+import ActionType from 'enum/action-type';
+import LoadBlockOperation from 'server/operation/load-block';
+import AddBlockAction from 'type/action/add-block';
+import LoadAccountOperation from 'server/operation/load-account';
+import DeleteBlockAction from 'type/action/delete-block';
+import EditBlockAction from 'type/action/edit-block';
+import Action from 'type/action';
+
+type GetActionInput = {};
+
+type GetActionOutput = Partial<Action>;
+
+class GetActionEndpoint extends BaseEndpoint<GetActionInput, GetActionOutput> {
+	public path = '/actions';
+	public method = HttpMethod.GET;
+	public content_types = [
+		ContentType.JSON,
+		ContentType.HTML
+	];
+
+	protected async process(): Promise<GetActionOutput> {
+		this.verifyLoggedIn();
+
+		const action_type = this.getActionType();
+
+		switch (action_type) {
+			case ActionType.ADD_BLOCK:
+				return this.processAddBlock();
+
+			case ActionType.DELETE_BLOCK:
+				return this.processDeleteBlock();
+
+			case ActionType.EDIT_BLOCK:
+				return this.processEditBlock();
+
+			default:
+				throw new InvalidError(`Unsupported action type: ${action_type}`);
+		}
+	}
+
+	private async processAddBlock(): Promise<Partial<AddBlockAction>> {
+		const path = this.getPath();
+		const action_type = ActionType.ADD_BLOCK;
+		const block_type = this.getQueryParameter('block_type') as BlockType.NOTE | BlockType.IMAGE | undefined;
+		const editing = this.getQueryParameter('editing') === 'true';
+		const index_path = this.getQueryParameter('index_path') as string;
+
+		if (typeof index_path !== 'string') {
+			throw new InvalidError(`Invalid index path: ${index_path}`);
+		}
+
+		const parent_block = await this.loadParentBlock();
+		const parent_permissions = getBlockPermissions(parent_block);
+		const create_role = parent_permissions[PermissionType.CREATE];
+		const read_role = parent_permissions[PermissionType.READ];
+		const update_role = parent_permissions[PermissionType.UPDATE];
+		const delete_role = parent_permissions[PermissionType.DELETE];
+
+		return {
+			path,
+			action_type,
+			block_type,
+			index_path,
+			create_role,
+			read_role,
+			update_role,
+			delete_role,
+			editing
+		};
+	}
+
+	private async processDeleteBlock(): Promise<Partial<DeleteBlockAction>> {
+		const path = this.getPath();
+		const action_type = ActionType.DELETE_BLOCK;
+		const index_path = this.getQueryParameter('index_path') as string;
+
+		if (typeof index_path !== 'string') {
+			throw new InvalidError(`Invalid index path: ${index_path}`);
+		}
+
+		const execution_context = this.getExecutionContext();
+		const operation = new LoadBlockOperation(path, index_path, execution_context);
+		const block = await operation.perform();
+		const editing = false;
+
+		return {
+			path,
+			action_type,
+			index_path,
+			editing,
+			block
+		};
+	}
+
+	private async processEditBlock(): Promise<Partial<EditBlockAction>> {
+		const path = this.getPath();
+		const action_type = ActionType.EDIT_BLOCK;
+		const index_path = this.getQueryParameter('index_path');
+
+		if (typeof index_path !== 'string') {
+			throw new InvalidError(`Invalid index path: ${index_path}`);
+		}
+
+		const execution_context = this.getExecutionContext();
+		const operation = new LoadBlockOperation(path, index_path, execution_context);
+		const block = await operation.perform();
+		const editing = false;
+
+		return {
+			path,
+			action_type,
+			index_path,
+			editing,
+			block
+		};
+	}
+
+	protected async getHtmlResultSerializer(result: GetActionOutput): Promise<ActionResultSerializer> {
+		const session = this.getSession();
+		const path = '/actions';
+		const referrer_url = this.getReferrerUrl();
+		const execution_context = this.getExecutionContext();
+		const account_operation = new LoadAccountOperation(execution_context);
+		const {providers, roles} = execution_context.getConfig();
+		const provider_paths = Object.keys(providers);
+		const account = await account_operation.perform();
+
+		if (account === null) {
+			throw new InvariantViolation(`
+				Tried to read account for logged in user,
+				but they were not set
+			`);
+		}
+
+		const metadata = {
+			account,
+			roles,
+			provider_paths
+		};
+
+		return new ActionResultSerializer(
+			result,
+			metadata,
+			path,
+			referrer_url,
+			session
+		);
+	}
+
+	private async loadParentBlock(): Promise<Block> {
+		const path = this.getPath();
+		const parent_path = getParentPath(path);
+		const execution_context = this.getExecutionContext();
+		const page_operation = new LoadPageOperation(parent_path, execution_context);
+		const parent_page = await page_operation.perform();
+		const {blocks} = parent_page;
+
+		const parent_block = blocks.find((block) => {
+			const {block_type} = block;
+
+			if (block_type !== BlockType.FOLDER) {
+				return false;
+			}
+
+			const folder_path = getPathForFolderBlock({
+				base_path: '/',
+				block: block as FolderBlock
+			});
+
+			return folder_path === path;
+		});
+
+		if (parent_block === undefined) {
+			return {
+				block_type: BlockType.FOLDER,
+				created_at: Date.now(),
+				title: 'index',
+				subtitle: '',
+				emoji: Emoji.FOLDER,
+				color: Color.GREY
+			} as FolderBlock;
+		}
+
+		return parent_block;
+	}
+
+	private getActionType(): ActionType {
+		const action_type = this.getQueryParameter('action_type');
+
+		if (typeof action_type !== 'string') {
+			throw new InvalidError(`
+				Invalid action_type: ${action_type}
+				(was ${typeof action_type})
+			`);
+		}
+
+		return action_type as ActionType;
+	}
+
+	private getPath(): string {
+		const path = this.getQueryParameter('path');
+
+		if (typeof path !== 'string') {
+			throw new InvalidError(`
+				Invalid path: ${path}
+			`);
+		}
+
+		validatePath(path);
+
+		return path;
+	}
+}
+
+export default GetActionEndpoint;

package/src/server/endpoint/base.ts

@@ -0,0 +1,51 @@
+import {Endpoint} from 'lib/server';
+import {HttpHeader} from 'lib/http';
+import {InvariantViolation, UnauthorizedError} from 'lib/errors';
+
+import validateUrl from 'server/utility/validate-url';
+
+type AllowedOutputs = string | Buffer | object;
+
+abstract class BaseEndpoint<I, O extends AllowedOutputs> extends Endpoint<I, O> {
+	protected getHost(): string {
+		const request = this.getRequest();
+		const host = request.getHeaderValue(HttpHeader.HOST);
+
+		if (host === undefined) {
+			throw new InvariantViolation(`
+				Tried to read request host, but it was not set
+			`);
+		}
+
+		return host;
+	}
+
+	protected getReferrerUrl(): string {
+		const request = this.getRequest();
+		const referrer = request.getHeaderValue(HttpHeader.REFERER);
+
+		if (referrer !== undefined) {
+			validateUrl(referrer);
+
+			return referrer;
+		}
+
+		const host = this.getHost();
+		const protocol = request.getProtocol();
+		const host_url = `${protocol}://${host}`;
+
+		validateUrl(host_url);
+
+		return host_url;
+	}
+
+	protected verifyLoggedIn(): void {
+		const session = this.getSession();
+
+		if (session.account_id === null) {
+			throw new UnauthorizedError();
+		}
+	}
+}
+
+export default BaseEndpoint;

package/src/server/endpoint/day.ts

@@ -0,0 +1,13 @@
+import AbstractPageEndpoint from 'server/endpoint/abstract-page';
+
+class DayEndpoint extends AbstractPageEndpoint {
+	public path = '/day/:date';
+
+	protected async determinePath(): Promise<string> {
+		const key = this.getPathParameter('date');
+
+		return `/day/${key}`;
+	}
+}
+
+export default DayEndpoint;

package/src/server/endpoint/generic-page.ts

@@ -0,0 +1,14 @@
+import AbstractPageEndpoint from 'server/endpoint/abstract-page';
+
+class GenericPageEndpoint extends AbstractPageEndpoint {
+	public path = '/[A-Za-z0-9\/-]+';
+
+	protected async determinePath(): Promise<string> {
+		const request = this.getRequest();
+		const path = request.getPath();
+
+		return path;
+	}
+}
+
+export default GenericPageEndpoint;

package/src/server/endpoint/index.ts

@@ -0,0 +1,11 @@
+import AbstractPageEndpoint from 'server/endpoint/abstract-page';
+
+class IndexEndpoint extends AbstractPageEndpoint {
+	public path = '/';
+
+	protected async determinePath(): Promise<string> {
+		return '/';
+	}
+}
+
+export default IndexEndpoint;

package/src/server/endpoint/login.ts

@@ -0,0 +1,45 @@
+import {HttpMethod, ContentType} from 'lib/http';
+import {InvalidError} from 'lib/errors';
+
+import LoginResultSerializer from 'server/result-serializer/login';
+import BaseEndpoint from 'server/endpoint/base';
+
+type LoginInput = {};
+
+type LoginOutput = {
+	readonly source_path: string;
+};
+
+class LoginEndpoint extends BaseEndpoint<LoginInput, LoginOutput> {
+	public path = '/login';
+	public method = HttpMethod.GET;
+	public content_types = [
+		ContentType.HTML
+	];
+
+	protected async process(): Promise<LoginOutput> {
+		const raw_source = this.getQueryParameter('source') || '/';
+
+		if (typeof raw_source !== 'string') {
+			throw new InvalidError(`
+				Invalid source path: ${raw_source}
+			`);
+		}
+
+		const source_path = encodeURIComponent(raw_source);
+
+		return {
+			source_path
+		};
+	}
+
+	protected async getHtmlResultSerializer(result: LoginOutput): Promise<LoginResultSerializer> {
+		const session = this.getSession();
+		const path = '/login';
+		const referrer_url = this.getReferrerUrl();
+
+		return new LoginResultSerializer(result, path, referrer_url, session);
+	}
+}
+
+export default LoginEndpoint;

package/src/server/endpoint/logout.ts

@@ -0,0 +1,38 @@
+import {StatusCode, HttpHeader, HttpMethod, ContentType} from 'lib/http';
+
+import DestroySessionOperation from 'server/operation/destroy-session';
+import BaseEndpoint from 'server/endpoint/base';
+
+type LogoutInput = {};
+type LogoutOutput = string;
+
+class LogoutEndpoint extends BaseEndpoint<LogoutInput, LogoutOutput> {
+	public path = '/logout';
+	public method = HttpMethod.GET;
+	public content_types = [
+		ContentType.JSON,
+		ContentType.HTML
+	];
+
+	protected async process(): Promise<LogoutOutput> {
+		const session = this.getSession();
+		const execution_context = this.getExecutionContext();
+
+		const operation = new DestroySessionOperation(
+			session.id,
+			execution_context
+		);
+
+		await operation.perform();
+
+		const response = this.getResponse();
+		const url = '/?toast_message=logged+out&toast_color=%23FC3';
+
+		response.setHeaderValue(HttpHeader.LOCATION, url);
+		response.setStatusCode(StatusCode.REDIRECT);
+
+		return '';
+	}
+}
+
+export default LogoutEndpoint;

package/src/server/endpoint/month.ts

@@ -0,0 +1,35 @@
+import {HttpMethod, ContentType} from 'lib/http';
+
+import BaseEndpoint from 'server/endpoint/base';
+import Month from 'type/month';
+import MonthResultSerializer from 'server/result-serializer/month';
+import validateMonth from 'server/utility/validate-month';
+
+class MonthEndpoint extends BaseEndpoint<unknown, Month> {
+	public path = '/month/:key';
+	public method = HttpMethod.GET;
+
+	public content_types = [
+		ContentType.HTML,
+		ContentType.JSON
+	];
+
+	protected async process(): Promise<Month> {
+		const key = this.getPathParameter('key');
+
+		return validateMonth({
+			key
+		});
+	}
+
+	protected async getHtmlResultSerializer(result: Month): Promise<MonthResultSerializer> {
+		const session = this.getSession();
+		const request = this.getRequest();
+		const path = request.getPath();
+		const referrer_url = this.getReferrerUrl();
+
+		return new MonthResultSerializer(result, path, referrer_url, session);
+	}
+}
+
+export default MonthEndpoint;

package/src/server/endpoint/robots.ts

@@ -0,0 +1,18 @@
+import {HttpMethod, ContentType} from 'lib/http';
+
+import BaseEndpoint from 'server/endpoint/base';
+
+class RobotsEndpoint extends BaseEndpoint<unknown, string> {
+	public path = '/robots.txt';
+	public method = HttpMethod.GET;
+
+	public content_types = [
+		ContentType.TEXT
+	];
+
+	protected async process(): Promise<string> {
+		return 'User-agent: *\nDisallow: /\n';
+	}
+}
+
+export default RobotsEndpoint;

package/src/server/endpoint/session/create.ts

@@ -0,0 +1,62 @@
+import {StatusCode, HttpHeader, HttpMethod, ContentType} from 'lib/http';
+import {InvalidError} from 'lib/errors';
+
+import CreateSessionOperation from 'server/operation/create-session';
+import BaseEndpoint from 'server/endpoint/base';
+import Color from 'enum/color';
+import createToastPath from 'server/utility/create-toast-path';
+
+type CreateSessionInput = {
+	readonly username: string;
+	readonly password: string;
+	readonly source: string;
+};
+
+type CreateSessionOutput = string;
+
+class CreateSessionEndpoint extends BaseEndpoint<CreateSessionInput, CreateSessionOutput> {
+	public path = '/session';
+	public method = HttpMethod.POST;
+	public content_types = [
+		ContentType.JSON,
+		ContentType.HTML
+	];
+
+	protected async process(): Promise<CreateSessionOutput> {
+		const {username, password, source} = this.getRequestBody();
+
+		if (username === undefined) {
+			throw new InvalidError('Must specify a username');
+		}
+
+		if (password === undefined) {
+			throw new InvalidError('Must specify a password');
+		}
+
+		const execution_context = this.getExecutionContext();
+
+		const operation = new CreateSessionOperation(
+			username,
+			password,
+			execution_context
+		);
+
+		const session = await operation.perform();
+		const response = this.getResponse();
+		const target_path = decodeURIComponent(source);
+
+		const toasted_path = createToastPath(target_path, {
+			message: `welcome ${username}`,
+			color: Color.GREEN
+		});
+
+		response.setHeaderValue(HttpHeader.LOCATION, toasted_path);
+		response.setStatusCode(StatusCode.REDIRECT);
+
+		this.setSession(session);
+
+		return '';
+	}
+}
+
+export default CreateSessionEndpoint;

package/src/server/endpoint/settings/get.ts

@@ -0,0 +1,40 @@
+import {HttpMethod, ContentType} from 'lib/http';
+import {UnauthorizedError} from 'lib/errors';
+
+import SettingsResultSerializer from 'server/result-serializer/settings';
+import BaseEndpoint from 'server/endpoint/base';
+import AccountSettings from 'type/account-settings';
+import LoadAccountOperation from 'server/operation/load-account';
+
+type SettingsInput = {};
+type SettingsOutput = AccountSettings;
+
+class SettingsEndpoint extends BaseEndpoint<SettingsInput, SettingsOutput> {
+	public path = '/settings';
+	public method = HttpMethod.GET;
+	public content_types = [
+		ContentType.HTML
+	];
+
+	protected async process(): Promise<SettingsOutput> {
+		const execution_context = this.getExecutionContext();
+		const operation = new LoadAccountOperation(execution_context);
+		const account = await operation.perform();
+
+		if (account === null) {
+			throw new UnauthorizedError();
+		}
+
+		return account.settings;
+	}
+
+	protected async getHtmlResultSerializer(result: SettingsOutput): Promise<SettingsResultSerializer> {
+		const session = this.getSession();
+		const path = '/settings';
+		const referrer_url = this.getReferrerUrl();
+
+		return new SettingsResultSerializer(result, path, referrer_url, session);
+	}
+}
+
+export default SettingsEndpoint;

package/src/server/endpoint/settings/update.ts

@@ -0,0 +1,44 @@
+import {StatusCode, HttpHeader, HttpMethod, ContentType} from 'lib/http';
+
+import AccountSettings from 'type/account-settings';
+import UpdateAccountSettingsOperation from 'server/operation/update-account-settings';
+import BaseEndpoint from 'server/endpoint/base';
+import Color from 'enum/color';
+import createToastPath from 'server/utility/create-toast-path';
+
+type UpdateSettingsInput = AccountSettings;
+type UpdateSettingsOutput = string;
+
+class UpdateSettingsEndpoint extends BaseEndpoint<UpdateSettingsInput, UpdateSettingsOutput> {
+	public path = '/settings';
+	public method = HttpMethod.POST;
+	public content_types = [
+		ContentType.JSON,
+		ContentType.HTML
+	];
+
+	protected async process(): Promise<UpdateSettingsOutput> {
+		const path = createToastPath('/', {
+			message: 'settings updated',
+			color: Color.GREEN
+		});
+
+		const response = this.getResponse();
+		const body = this.getRequestBody();
+		const execution_context = this.getExecutionContext();
+
+		const operation = new UpdateAccountSettingsOperation(
+			body,
+			execution_context
+		);
+
+		await operation.perform();
+
+		response.setHeaderValue(HttpHeader.LOCATION, path);
+		response.setStatusCode(StatusCode.REDIRECT);
+
+		return '';
+	}
+}
+
+export default UpdateSettingsEndpoint;

package/src/server/endpoint/today.ts

@@ -0,0 +1,15 @@
+import AbstractPageEndpoint from 'server/endpoint/abstract-page';
+import createDate from 'server/utility/create-date';
+import dateToPath from 'server/utility/date-to-path';
+
+class TodayEndpoint extends AbstractPageEndpoint {
+	public path = '/today';
+
+	protected async determinePath(): Promise<string> {
+		const today = createDate();
+
+		return dateToPath(today);
+	}
+}
+
+export default TodayEndpoint;

package/src/server/endpoint/week.ts

@@ -0,0 +1,34 @@
+import {HttpMethod, ContentType} from 'lib/http';
+
+import BaseEndpoint from 'server/endpoint/base';
+import Week from 'type/week';
+import WeekResultSerializer from 'server/result-serializer/week';
+
+class WeekEndpoint extends BaseEndpoint<unknown, Week> {
+	public path = '/week/:week';
+	public method = HttpMethod.GET;
+
+	public content_types = [
+		ContentType.HTML,
+		ContentType.JSON
+	];
+
+	protected async process(): Promise<Week> {
+		const key = this.getPathParameter('week');
+
+		return {
+			key
+		};
+	}
+
+	protected async getHtmlResultSerializer(result: Week): Promise<WeekResultSerializer> {
+		const session = this.getSession();
+		const request = this.getRequest();
+		const path = request.getPath();
+		const referrer_url = this.getReferrerUrl();
+
+		return new WeekResultSerializer(result, path, referrer_url, session);
+	}
+}
+
+export default WeekEndpoint;

package/src/server/endpoint/year.ts

@@ -0,0 +1,34 @@
+import {HttpMethod, ContentType} from 'lib/http';
+
+import BaseEndpoint from 'server/endpoint/base';
+import YearResultSerializer from 'server/result-serializer/year';
+import Year from 'type/year';
+
+class YearEndpoint extends BaseEndpoint<unknown, Year> {
+	public path = '/year/:year';
+	public method = HttpMethod.GET;
+
+	public content_types = [
+		ContentType.HTML,
+		ContentType.JSON
+	];
+
+	protected async process(): Promise<Year> {
+		const key = this.getPathParameter('year');
+
+		return {
+			key
+		};
+	}
+
+	protected async getHtmlResultSerializer(result: Year): Promise<YearResultSerializer> {
+		const session = this.getSession();
+		const request = this.getRequest();
+		const path = request.getPath();
+		const referrer_url = this.getReferrerUrl();
+
+		return new YearResultSerializer(result, path, referrer_url, session);
+	}
+}
+
+export default YearEndpoint;