@fc3/mmcadi 0.1.0

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

@@ -0,0 +1,126 @@
+import {ContentType, HttpMethod} from 'lib/http';
+
+import PageResultSerializer, {PageMetadata} from 'server/result-serializer/page';
+import BaseEndpoint from 'server/endpoint/base';
+import BlockType from 'enum/block-type';
+import LoadPageOperation from 'server/operation/load-page';
+import getPathForFolderBlock from 'server/utility/get-path-for-folder-block';
+import FolderBlock from 'type/block/folder';
+import validateUrl from 'server/utility/validate-url';
+import Page from 'type/page';
+import createIndexPath from 'server/utility/create-index-path';
+import getCustomPageTypeForPath from 'server/utility/get-custom-page-type-for-path';
+import Toast from 'type/toast';
+import LoadAccountOperation from 'server/operation/load-account';
+import Color from 'enum/color';
+
+type PageInput = {}
+type PageOutput = Page;
+
+abstract class AbstractPageEndpoint extends BaseEndpoint<PageInput, PageOutput> {
+	public method = HttpMethod.GET;
+
+	public content_types = [
+		ContentType.HTML,
+		ContentType.JSON
+	];
+
+	protected async process(): Promise<PageOutput> {
+		const execution_context = this.getExecutionContext();
+		const session = this.getSession();
+
+		execution_context.setSession(session);
+
+		const path = await this.determinePath();
+		const operation = new LoadPageOperation(path, execution_context);
+
+		return operation.perform();
+	}
+
+	protected async getHtmlResultSerializer(page: Page): Promise<PageResultSerializer> {
+		const editing = this.getQueryParameter('editing') === 'true';
+
+		const target_index_path = (() => {
+			const path_parameter = this.getQueryParameter('index_path') as string;
+
+			if (path_parameter) {
+				return path_parameter;
+			}
+
+			const referrer_url = this.getReferrerUrl();
+
+			if (referrer_url !== null) {
+				let index = 0;
+
+				while (index < page.blocks.length) {
+					const block = page.blocks[index];
+
+					if (block.block_type === BlockType.FOLDER) {
+						const folder_block = block as FolderBlock;
+
+						const block_path = getPathForFolderBlock({
+							base_path: page.path,
+							block: folder_block
+						});
+
+						validateUrl(referrer_url);
+
+						const url = new URL(referrer_url);
+
+						if (url.pathname === block_path) {
+							return createIndexPath([index]);
+						}
+					}
+
+					index++;
+				}
+			}
+
+			return null;
+		})();
+
+		const toast_message = this.getQueryParameter('toast_message') as string;
+		const custom_page_type = getCustomPageTypeForPath(page.path);
+
+		let toast: Toast | null = null;
+
+		if (toast_message) {
+			const raw_color = this.getQueryParameter('toast_color') as string;
+			const toast_color = raw_color ? decodeURIComponent(raw_color) as Color : Color.GREY;
+
+			toast = {
+				message: decodeURIComponent(toast_message),
+				color: toast_color
+			};
+		}
+
+		const execution_context = this.getExecutionContext();
+		const account_operation = new LoadAccountOperation(execution_context);
+		const account = await account_operation.perform();
+		const {roles} = execution_context.getConfig();
+
+		const metadata: PageMetadata = {
+			editing,
+			target_index_path,
+			toast,
+			custom_page_type,
+			roles,
+			account
+		};
+
+		const session = this.getSession();
+		const referrer_url = this.getReferrerUrl();
+
+		return new PageResultSerializer(
+			page,
+			metadata,
+			page.path,
+			referrer_url,
+			session
+		);
+	}
+
+	protected abstract determinePath(): Promise<string>;
+}
+
+export default AbstractPageEndpoint;

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

@@ -0,0 +1,545 @@
+import {unlink, copyFile, mkdir} from 'fs/promises';
+
+import {ContentType, HttpMethod, HttpHeader, StatusCode} from 'lib/http';
+import {InvalidError, UnauthorizedError} from 'lib/errors';
+
+import BaseEndpoint from 'server/endpoint/base';
+import AddBlockOperation from 'server/operation/add-block';
+import Emoji from 'enum/emoji';
+import DeleteBlockOperation from 'server/operation/delete-block';
+import Color from 'enum/color';
+import PromoteBlockOperation from 'server/operation/promote-block';
+import PermissionType from 'enum/permission-type';
+import getBlockAtIndexPath from 'server/utility/get-block-at-index-path';
+import MultiColumnBlock from 'type/block/multi-column';
+import LinkBlock from 'type/block/link';
+import DemoteBlockOperation from 'server/operation/demote-block';
+import UpdateBlockOperation from 'server/operation/update-block';
+import createToastPath from 'server/utility/create-toast-path';
+import TimePlaceVisibility from 'enum/time-place-visibility';
+import LoadPageOperation from 'server/operation/load-page';
+import File from 'type/file';
+import HeaderBlock from 'type/block/header';
+import TodoBlock from 'type/block/todo';
+import BlockType from 'enum/block-type';
+import AudioBlock from 'type/block/audio';
+import BackgroundBlock from 'type/block/background';
+import WhitespaceBlock from 'type/block/whitespace';
+import NoteBlock from 'type/block/note';
+import FolderBlock from 'type/block/folder';
+import ImageBlock from 'type/block/image';
+import Block from 'type/block';
+import ActionType from 'enum/action-type';
+import AddBlockAction, {
+	AddFolderBlockAction,
+	AddLinkBlockAction,
+	AddNoteBlockAction,
+	AddHeaderBlockAction,
+	AddTodoBlockAction,
+	AddMultiColumnBlockAction,
+	AddWhitespaceBlockAction,
+	AddBackgroundBlockAction
+} from 'type/action/add-block';
+import DeleteBlockAction from 'type/action/delete-block';
+import CompleteBlockAction from 'type/action/complete-block';
+import DemoteBlockAction from 'type/action/demote-block';
+import PromoteBlockAction from 'type/action/promote-block';
+import Action from 'type/action';
+import getPreviousIndexPath from 'server/utility/get-previous-index-path';
+
+type MultipartFile = {
+	readonly filepath: string;
+	readonly size: number;
+	readonly mimetype: string;
+	readonly originalFilename: string;
+}
+
+type FilePayload = {
+	readonly files: MultipartFile[];
+}
+
+type ActionWithFiles = Action & FilePayload;
+
+type CreateActionInput = Action;
+type CreateActionOutput = string;
+
+class CreateActionEndpoint extends BaseEndpoint<CreateActionInput, CreateActionOutput> {
+	public path = '/actions';
+	public method = HttpMethod.POST;
+	public content_types = [
+		ContentType.JSON,
+		ContentType.HTML
+	];
+
+	protected async authorize(): Promise<void> {
+		const session = this.getSession();
+		const {account_id} = session;
+
+		if (account_id === null) {
+			throw new UnauthorizedError();
+		}
+	}
+
+	protected async process(): Promise<CreateActionOutput> {
+		const redirect_url = await this.processBlock();
+		const response = this.getResponse();
+
+		response.setHeaderValue(HttpHeader.LOCATION, redirect_url);
+		response.setStatusCode(StatusCode.REDIRECT);
+
+		return '';
+	}
+
+	private async processBlock(): Promise<string> {
+		const action_type = this.getActionType();
+
+		switch (action_type) {
+			case ActionType.ADD_BLOCK:
+				return this.processAddBlock();
+
+			case ActionType.DELETE_BLOCK:
+				return this.processDeleteBlock();
+
+			case ActionType.PROMOTE_BLOCK:
+				return this.processPromoteBlock();
+
+			case ActionType.DEMOTE_BLOCK:
+				return this.processDemoteBlock();
+
+			case ActionType.EDIT_BLOCK:
+				return this.processEditBlock();
+
+			case ActionType.COMPLETE_BLOCK:
+				return this.processCompleteBlock();
+
+			default:
+				throw new InvalidError(`Unsupported action type: ${action_type}`);
+		}
+	}
+
+	private async processAddBlock(): Promise<string> {
+		const filenames = await this.storeFiles();
+		const body = this.getRequestBody() as AddBlockAction;
+		const editing = this.getQueryParameter('editing') === 'true';
+
+		const action: AddBlockAction = {
+			...body,
+			editing
+		};
+
+		const {index_path} = action;
+
+		const files = filenames.map((filename) => {
+			const description = null;
+
+			return {
+				filename,
+				description
+			}
+		});
+
+		const path = this.getPath();
+		const block = this.loadBlockParameters(files);
+		const execution_context = this.getExecutionContext();
+
+		const page_operation = new LoadPageOperation(path, execution_context);
+		const page = await page_operation.perform();
+
+		const block_operation = new AddBlockOperation(
+			page,
+			block,
+			index_path,
+			execution_context
+		);
+
+		await block_operation.perform();
+
+		return `${path}?index_path=${index_path}&editing=${editing}`;
+	}
+
+	private async processCompleteBlock(): Promise<string> {
+		const path = this.getPath();
+		const body = this.getRequestBody() as CompleteBlockAction;
+		const {index_path} = body;
+		const execution_context = this.getExecutionContext();
+		const page_operation = new LoadPageOperation(path, execution_context);
+		const page = await page_operation.perform();
+		const original_block = getBlockAtIndexPath(page, index_path);
+
+		const todo_block = original_block as TodoBlock;
+		const {title} = todo_block;
+		const completed_at = Date.now();
+		const editing = this.getQueryParameter('editing') === 'true';
+
+		const updated_block = {
+			...todo_block,
+			completed_at
+		};
+
+		const block_operation = new UpdateBlockOperation(
+			page,
+			updated_block,
+			index_path,
+			execution_context
+		);
+
+		await block_operation.perform();
+
+		return createToastPath(`${path}?index_path=${index_path}&editing=${editing}`, {
+			message: `${Emoji.COMPLETED_CHECKMARK} todo completed: ${title}`,
+			color: Color.GREEN
+		});
+	}
+
+	private async processEditBlock(): Promise<string> {
+		const filenames = await this.storeFiles();
+		const body = this.getRequestBody();
+		const action = body as AddBlockAction;
+		const editing = this.getQueryParameter('editing') === 'true';
+		const {index_path} = action;
+
+		const files = filenames.map((filename) => {
+			const description = null;
+
+			return {
+				filename,
+				description
+			}
+		});
+
+		const path = this.getPath();
+		const block = this.loadBlockParameters(files);
+		const execution_context = this.getExecutionContext();
+
+		const page_operation = new LoadPageOperation(path, execution_context);
+		const page = await page_operation.perform();
+
+		const block_operation = new UpdateBlockOperation(
+			page,
+			block,
+			index_path,
+			execution_context
+		);
+
+		await block_operation.perform();
+
+		return `${path}?index_path=${index_path}&editing=${editing}`;
+	}
+
+	private loadBlockParameters(files: File[]): Block {
+		const action = this.getRequestBody() as AddBlockAction;
+		const {block_type} = action;
+		const created_at = Date.now();
+		const visibility = action.time_place_visibility;
+
+		const {create_role, read_role, update_role, delete_role} = action;
+		const permissions = {
+			[PermissionType.CREATE]: create_role,
+			[PermissionType.READ]: read_role,
+			[PermissionType.UPDATE]: update_role,
+			[PermissionType.DELETE]: delete_role
+		};
+
+		const [show_time, show_place] = (() => {
+			switch (visibility) {
+				case TimePlaceVisibility.NONE:
+					return [false, false];
+
+				case TimePlaceVisibility.PLACE:
+					return [false, true];
+
+				case TimePlaceVisibility.BOTH:
+					return [true, true];
+
+				case TimePlaceVisibility.TIME:
+				default:
+					return [true, false];
+			}
+		})();
+
+		switch (block_type) {
+			case BlockType.NOTE:
+				const add_note_action = action as AddNoteBlockAction;
+
+				const a: NoteBlock = {
+					block_type,
+					text: add_note_action.text,
+					show_time,
+					show_place,
+					created_at,
+					permissions
+				};
+
+				return a;
+
+			case BlockType.IMAGE:
+				const b: ImageBlock = {
+					block_type,
+					files,
+					show_time,
+					show_place,
+					created_at,
+					permissions
+				};
+
+				return b;
+
+			case BlockType.AUDIO:
+				const c: AudioBlock = {
+					block_type,
+					files,
+					show_time,
+					show_place,
+					created_at,
+					permissions
+				};
+
+				return c;
+
+			case BlockType.HEADER:
+				const add_header_action = action as AddHeaderBlockAction;
+
+				const d: HeaderBlock = {
+					block_type,
+					title: add_header_action.title,
+					created_at,
+					show_time: false,
+					show_place: false,
+					permissions
+				};
+
+				return d;
+
+			case BlockType.FOLDER:
+				const add_folder_action = action as AddFolderBlockAction;
+				const default_emoji = Emoji.FOLDER;
+				const default_color = Color.GREY;
+
+				const e: FolderBlock = {
+					block_type,
+					title: add_folder_action.title,
+					subtitle: add_folder_action.subtitle,
+					emoji: add_folder_action.emoji || default_emoji,
+					color: add_folder_action.color || default_color,
+					created_at,
+					show_time: false,
+					show_place: false,
+					permissions
+				};
+
+				return e;
+
+			case BlockType.MULTI_COLUMN:
+				const {max_columns} = action as AddMultiColumnBlockAction;
+				const parsed_columns = parseInt(max_columns.toString());
+
+				const f: MultiColumnBlock = {
+					block_type,
+					created_at,
+					show_time: false,
+					show_place: false,
+					max_columns: parsed_columns || 3,
+					children: [],
+					permissions
+				};
+
+				return f;
+
+			case BlockType.TODO:
+				const add_todo_action = action as AddTodoBlockAction;
+
+				const g: TodoBlock = {
+					block_type,
+					title: add_todo_action.title,
+					completed_at: null,
+					created_at,
+					show_time: false,
+					show_place: false,
+					permissions
+				};
+
+				return g;
+
+			case BlockType.LINK:
+				const add_link_action = action as AddLinkBlockAction;
+
+				const h: LinkBlock = {
+					block_type,
+					label: add_link_action.label,
+					href: add_link_action.href,
+					color: add_link_action.color,
+					show_time,
+					show_place,
+					created_at,
+					permissions
+				};
+
+				return h;
+
+			case BlockType.BACKGROUND:
+				const add_background_action = action as AddBackgroundBlockAction;
+
+				const i: BackgroundBlock = {
+					block_type,
+					color: add_background_action.color,
+					show_time,
+					show_place,
+					created_at,
+					permissions
+				};
+
+				return i;
+
+			case BlockType.WHITESPACE:
+				const add_whitespace_action = action as AddWhitespaceBlockAction;
+
+				const j: WhitespaceBlock = {
+					block_type,
+					line_count: add_whitespace_action.line_count,
+					show_time,
+					show_place,
+					created_at,
+					permissions
+				};
+
+				return j;
+
+			default:
+				throw new InvalidError(`
+					Unsupported block type: ${block_type}
+				`);
+		}
+	}
+
+	private async processDeleteBlock(): Promise<string> {
+		const body = this.getRequestBody();
+		const action = body as DeleteBlockAction;
+		const {index_path} = action;
+		const path = this.getPath();
+		const execution_context = this.getExecutionContext();
+		const editing = this.getQueryParameter('editing') === 'true';
+
+		const operation = new DeleteBlockOperation(
+			path,
+			index_path,
+			execution_context
+		);
+
+		const previous_path = getPreviousIndexPath(index_path);
+
+		await operation.perform();
+
+		return createToastPath(`${path}?editing=${editing}&index_path=${previous_path}`, {
+			message: 'block deleted',
+			color: Color.FUSCHIA
+		});
+	}
+
+	private async processPromoteBlock(): Promise<string> {
+		const path = this.getPath();
+		const body = this.getRequestBody();
+		const action = body as PromoteBlockAction;
+		const {index_path} = action;
+		const editing = this.getQueryParameter('editing') === 'true';
+		const execution_context = this.getExecutionContext();
+		const operation = new PromoteBlockOperation(path, index_path, execution_context);
+		const updated_path = await operation.perform();
+
+		return `${path}?index_path=${updated_path}&editing=${editing}`;
+	}
+
+	private async processDemoteBlock(): Promise<string> {
+		const path = this.getPath();
+		const body = this.getRequestBody();
+		const action = body as DemoteBlockAction;
+		const {index_path} = action;
+		const editing = this.getQueryParameter('editing') === 'true';
+		const execution_context = this.getExecutionContext();
+		const operation = new DemoteBlockOperation(path, index_path, execution_context);
+		const updated_path = await operation.perform();
+
+		return `${path}?index_path=${updated_path}&editing=${editing}`;
+	}
+
+	private getActionType(): ActionType {
+		const request_body = this.getRequestBody()
+		const fallback_value = this.getQueryParameter('action_type');
+
+		const action_type = request_body.action_type || fallback_value;
+
+		if (typeof action_type !== 'string') {
+			throw new InvalidError(`Invalid action_type: ${action_type}`);
+		}
+
+		const action_types = Object.values(ActionType);
+
+		if (!action_types.includes(action_type)) {
+			throw new InvalidError(`Invalid action_type: ${action_type}`);
+		}
+
+		return action_type as ActionType;
+	}
+
+	private getPath(): string {
+		const {path} = this.getRequestBody();
+
+		if (typeof path !== 'string') {
+			throw new InvalidError(`
+				Invalid path: ${path}
+			`);
+		}
+
+		return path;
+	}
+
+	private async storeFiles(): Promise<string[]> {
+		const action = this.getRequestBody();
+		const path = this.getPath();
+		const {files} = action as ActionWithFiles;
+
+		if (files === undefined) {
+			return [];
+		}
+
+		const execution_context = this.getExecutionContext();
+		const logger = execution_context.getLogger();
+		const {public_directory} = execution_context.getConfig();
+		const page_path = `${public_directory}${path}`;
+
+		await mkdir(page_path, {
+			recursive: true
+		});
+
+		const filenames: string[] = [];
+
+		let index = 0;
+
+		while (index < files.length) {
+			const file = files[index++];
+
+			if (file.size === 0) {
+				continue;
+			}
+
+			const new_filename = file.originalFilename;
+			const new_filepath = `${page_path}/${new_filename}`;
+
+			logger.info(`Moving upload: ${file.filepath} -> ${new_filepath}`);
+
+			try {
+				await copyFile(file.filepath, new_filepath);
+				await unlink(file.filepath);
+			} catch (error) {
+				logger.error(error as Error);
+
+				throw error;
+			}
+
+			filenames.push(new_filename);
+		}
+
+		return filenames;
+	}
+}
+
+export default CreateActionEndpoint;