@fc3/mmcadi 0.1.0

package/src/server/enum/custom-page-type.ts

@@ -0,0 +1,10 @@
+enum CustomPageType {
+	BLANK = 'blank',
+	FORM = 'form',
+	PRODUCT = 'product',
+	DATE = 'date',
+	INDEX = 'index',
+	ERROR = 'error'
+}
+
+export default CustomPageType;

package/src/server/factory/block-result-serializer.ts

@@ -0,0 +1,115 @@
+import {InvalidError, InvariantViolation} from 'lib/errors';
+import {Session} from 'lib/execution-context';
+
+import Block from 'type/block';
+import BlockResultSerializer from 'server/result-serializer/block';
+import NoteBlock from 'type/block/note';
+import BlockMetadata from 'type/block-metadata';
+import ImageBlock from 'type/block/image';
+import HeaderBlock from 'type/block/header';
+import BlockType from 'enum/block-type';
+import AudioBlock from 'type/block/audio';
+import LinkBlock from 'type/block/link';
+import ListBlock from 'type/block/list';
+import EphemeralBlock from 'type/block/ephemeral';
+import DirectoryBlock from 'type/block/directory';
+import TodoBlock from 'type/block/todo';
+import BackgroundBlock from 'type/block/background';
+import TodoBlockResultSerializer from 'server/result-serializer/block/todo';
+import FolderBlock from 'type/block/folder';
+import WhitespaceBlock from 'type/block/whitespace';
+import MultiColumnBlock from 'type/block/multi-column';
+import NoteBlockResultSerializer from 'server/result-serializer/block/note';
+import LinkBlockResultSerializer from 'server/result-serializer/block/link';
+import ListBlockResultSerializer from 'server/result-serializer/block/list';
+import HeaderBlockResultSerializer from 'server/result-serializer/block/header';
+import WhitespaceBlockResultSerializer from 'server/result-serializer/block/whitespace';
+import BackgroundBlockResultSerializer from 'server/result-serializer/block/background';
+import ImageBlockResultSerializer from 'server/result-serializer/block/image';
+import AudioBlockResultSerializer from 'server/result-serializer/block/audio';
+import DirectoryBlockResultSerializer from 'server/result-serializer/block/directory';
+import MultiColumnBlockResultSerializer from 'server/result-serializer/block/multi-column';
+import FolderBlockResultSerializer from 'server/result-serializer/block/folder';
+import EphemeralBlockResultSerializer from 'server/result-serializer/block/ephemeral';
+
+class BlockResultSerializerFactory {
+	private block: Block;
+	private metadata: BlockMetadata;
+	private session: Session;
+
+	public constructor(block: Block, metadata: BlockMetadata, session: Session) {
+		this.block = block;
+		this.metadata = metadata;
+		this.session = session;
+	}
+
+	public create(): BlockResultSerializer<Block> {
+		const block = this.getBlock();
+
+		if (!block) {
+			throw new InvariantViolation('Tried to read block, but it was not set');
+		}
+
+		const {block_type} = block;
+		const metadata = this.getMetadata();
+		const session = this.getSession();
+
+		switch (block_type) {
+			case BlockType.NOTE:
+				return new NoteBlockResultSerializer(block as NoteBlock, metadata, session);
+
+			case BlockType.IMAGE:
+				return new ImageBlockResultSerializer(block as ImageBlock, metadata, session);
+
+			case BlockType.AUDIO:
+				return new AudioBlockResultSerializer(block as AudioBlock, metadata, session);
+
+			case BlockType.HEADER:
+				return new HeaderBlockResultSerializer(block as HeaderBlock, metadata, session)
+
+			case BlockType.EPHEMERAL:
+				return new EphemeralBlockResultSerializer(block as EphemeralBlock, metadata, session);
+
+			case BlockType.DIRECTORY:
+				return new DirectoryBlockResultSerializer(block as DirectoryBlock, metadata, session);
+
+			case BlockType.FOLDER:
+				return new FolderBlockResultSerializer(block as FolderBlock, metadata, session);
+
+			case BlockType.MULTI_COLUMN:
+				return new MultiColumnBlockResultSerializer(block as MultiColumnBlock, metadata, session);
+
+			case BlockType.LINK:
+				return new LinkBlockResultSerializer(block as LinkBlock, metadata, session);
+
+			case BlockType.TODO:
+				return new TodoBlockResultSerializer(block as TodoBlock, metadata, session);
+
+			case BlockType.LIST:
+				return new ListBlockResultSerializer(block as ListBlock, metadata, session);
+
+			case BlockType.BACKGROUND:
+				return new BackgroundBlockResultSerializer(block as BackgroundBlock, metadata, session);
+
+			case BlockType.WHITESPACE:
+				return new WhitespaceBlockResultSerializer(block as WhitespaceBlock, metadata, session);
+
+			default:
+				throw new InvalidError(`Unsupported block type: ${block_type}`);
+		}
+	}
+
+	private getBlock(): Block {
+		return this.block;
+	}
+
+	private getMetadata(): BlockMetadata {
+		return this.metadata;
+	}
+
+	private getSession(): Session {
+		return this.session;
+	}
+}
+
+export default BlockResultSerializerFactory;

package/src/server/middleware/base.ts

@@ -0,0 +1,6 @@
+import {Middleware} from 'lib/server';
+
+abstract class BaseMiddleware extends Middleware {
+}
+
+export default BaseMiddleware;

package/src/server/middleware/error-handler.ts

@@ -0,0 +1,177 @@
+import {
+	HttpHeader,
+	StatusCode,
+	ContentType,
+	IncomingRequest,
+	OutgoingResponse,
+	getStatusCodeForError
+} from 'lib/http';
+import {InvalidError, NotFoundError} from 'lib/errors';
+
+import BaseMiddleware from 'server/middleware/base';
+import LoadPageOperation from 'server/operation/load-page';
+import PageType from 'client/enum/page-type';
+import TimePlaceVisibility from 'enum/time-place-visibility';
+import getPathFromUrl from 'server/utility/get-path-from-url';
+import PageResultSerializer from 'server/result-serializer/page';
+import DefaultRole from 'enum/default-role';
+import validateUrl from 'server/utility/validate-url';
+import LoginResultSerializer from 'server/result-serializer/login';
+import CustomPageType from 'server/enum/custom-page-type';
+import Page from 'type/page';
+import HeaderBlock from 'type/block/header';
+import NoteBlock from 'type/block/note';
+import BlockType from 'enum/block-type';
+import acceptsHtml from 'server/utility/accepts-html';
+import acceptsJson from 'server/utility/accepts-json';
+
+function getReferrerUrl(request: IncomingRequest): string {
+	const referrer_header = request.getHeaderValue(HttpHeader.REFERER);
+	const host_header = request.getHeaderValue(HttpHeader.HOST);
+	const protocol = request.getProtocol();
+	const host_url = `${protocol}://${host_header}`;
+	const header_value = referrer_header || host_url;
+
+	if (header_value === undefined) {
+		throw new InvalidError('Request must specify a valid Host header');
+	}
+
+	validateUrl(header_value);
+
+	return header_value;
+}
+
+class ErrorHandlerMiddleware extends BaseMiddleware {
+	public async handleRequest(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<boolean> {
+		const path = request.getPath();
+		const error = new NotFoundError(path);
+
+		return this.handleError(error, request, response);
+	}
+
+	public async handleError(
+		error: Error,
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<boolean> {
+		const status_code = getStatusCodeForError(error);
+		const accepts_html = acceptsHtml(request);
+		const is_unauthorized = status_code === StatusCode.UNAUTHORIZED;
+
+		const session = request.getSession() || {
+			id: 'xxx',
+			account_id: null,
+			username: null
+		};
+
+		const referrer_url = getReferrerUrl(request);
+		const referrer_path = getPathFromUrl(referrer_url);
+
+		if (is_unauthorized && accepts_html) {
+			const result = {
+				source_path: referrer_path
+			};
+
+			const path = '/login';
+
+			const serializer = new LoginResultSerializer(
+				result,
+				path,
+				referrer_path,
+				session
+			);
+
+			const serialized_page = serializer.serialize();
+
+			response.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.HTML);
+			response.send(serialized_page);
+			return true;
+		}
+
+		const page_key = status_code.toString();
+		const page_path = `/${page_key}`;
+		const execution_context = request.getExecutionContext();
+
+		let page: Page;
+
+		try {
+			const operation = new LoadPageOperation(page_path, execution_context);
+
+			page = await operation.perform();
+		} catch (error) {
+			const now = Date.now();
+
+			page = {
+				path: page_path,
+				blocks: [
+					{
+						block_type: BlockType.HEADER,
+						title: page_key,
+						created_at: now,
+						show_time: false,
+						show_place: false
+					} as HeaderBlock,
+					{
+						block_type: BlockType.NOTE,
+						text: (error as Error).message,
+						created_at: now,
+						show_time: false,
+						show_place: false
+					} as NoteBlock
+				]
+			};
+		}
+
+		const metadata = {
+			editing: false,
+			referrer_url,
+			toast: null,
+			page_type: PageType.VIEW_CUSTOM,
+			custom_page_type: CustomPageType.ERROR,
+			target_index_path: null,
+			roles: Object.values(DefaultRole),
+			account: {
+				id: '',
+				username: '',
+				password: '',
+				role: DefaultRole.PUBLIC,
+				settings: {
+					default_time_place_visibility: TimePlaceVisibility.NONE,
+					tool_types: []
+				}
+			}
+		};
+
+		response.setStatusCode(status_code);
+
+		const path = request.getPath();
+
+		if (accepts_html) {
+			const serializer = new PageResultSerializer(
+				page,
+				metadata,
+				path,
+				referrer_url,
+				session
+			);
+
+			const serialized_page = serializer.serialize();
+
+			response.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.HTML);
+			response.send(serialized_page);
+		} else if (acceptsJson(request)) {
+			response.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.JSON);
+			response.error(error);
+		} else {
+			response.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.TEXT);
+			response.send(error.message);
+		}
+
+		return true;
+	}
+}
+
+export default ErrorHandlerMiddleware;

package/src/server/middleware/static-file.ts

@@ -0,0 +1,83 @@
+import FS from 'fs';
+
+import {
+	HttpHeader,
+	IncomingRequest,
+	OutgoingResponse,
+	getContentTypeForExtension
+} from 'lib/http';
+import {InvalidError} from 'lib/errors';
+import {exists, getExtensionForFilepath} from 'lib/filesystem';
+
+import BaseMiddleware from 'server/middleware/base';
+
+class StaticFileMiddleware extends BaseMiddleware {
+	public async handleRequest(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<boolean> {
+		let url = request.getPath();
+
+		if (url.includes('?')) {
+			const parts = url.split('?');
+
+			url = parts[0];
+		}
+
+		const execution_context = request.getExecutionContext();
+		const config = execution_context.getConfig();
+		const public_directory = config.public_directory;
+		const absolute_filepath = `${public_directory}${url}`;
+
+		if (absolute_filepath.includes('..') || absolute_filepath.includes('./')) {
+			throw new InvalidError('Illegal filepath');
+		}
+
+		// TODO: This was originally only being set for .mp3 file requests.
+		// Is it okay to enable it for all types of files?
+		response.setHeaderValue(HttpHeader.ACCESS_CONTROL_ALLOW_ORIGIN, '*');
+
+		// TODO: Determine whether this needs to be reenabled:
+		/*
+		const {base_url} = execution_context.getConfig();
+		const policy = `script-src ${base_url}`;
+
+		response.setHeaderValue(HttpHeader.CONTENT_SECURITY_POLICY, policy);
+		*/
+
+		const extension = getExtensionForFilepath(absolute_filepath);
+
+		if (extension === undefined) {
+			return false;
+		}
+
+		const content_type = getContentTypeForExtension(extension);
+
+		response.setHeaderValue(HttpHeader.CONTENT_TYPE, content_type);
+
+		const file_exists = await exists(absolute_filepath);
+
+		if (!file_exists) {
+			return false;
+		}
+
+		const stream = FS.createReadStream(absolute_filepath);
+		const native_response = response.getNativeResponse();
+
+		await new Promise<void>((resolve, reject) => {
+			stream.on('end', () => {
+				resolve();
+			});
+
+			stream.on('error', (error) => {
+				reject(error);
+			});
+
+			stream.pipe(native_response);
+		});
+
+		return true;
+	}
+}
+
+export default StaticFileMiddleware;

package/src/server/operation/add-block.ts

@@ -0,0 +1,110 @@
+import {mkdir} from 'fs/promises';
+import Path from 'path';
+
+import ExecutionContext from 'lib/execution-context';
+
+import Block from 'type/block';
+import BlockType from 'enum/block-type';
+import FolderBlock from 'type/block/folder';
+import createSlug from 'server/utility/create-slug';
+import getSiblingsAndIndexForIndexPath from 'server/utility/get-siblings-and-index-for-index-path';
+import HeaderBlock from 'type/block/header';
+import EphemeralBlock from 'type/block/ephemeral';
+import BaseOperation from 'operation';
+import Page from 'type/page';
+import SavePageOperation from 'server/operation/save-page';
+
+class AddBlockOperation extends BaseOperation<Block> {
+	private page: Page;
+	private block: Block;
+	private index_path: string;
+
+	public constructor(page: Page, block: Block, index_path: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.page = page;
+		this.block = block;
+		this.index_path = index_path;
+	}
+
+	protected async performInternal(): Promise<Block> {
+		await this.createBlockArtifacts();
+
+		return this.saveBlockToPage();
+	}
+
+	private async createBlockArtifacts(): Promise<void> {
+		const block = this.getBlock();
+		const {block_type} = block;
+
+		if (block_type !== BlockType.FOLDER) {
+			return;
+		}
+
+		const folder_block = block as FolderBlock;
+		const {title} = folder_block;
+		const slug = createSlug(title);
+		const {path} = this.getPage();
+		const {public_directory} = this.getConfig();
+		const new_path = Path.resolve(path, `./${slug}`);
+		const filepath = Path.resolve(public_directory, `.${new_path}`);
+
+		await mkdir(filepath, {
+			recursive: true
+		});
+
+		const created_at = Date.now();
+
+		const title_block: HeaderBlock = {
+			block_type: BlockType.HEADER,
+			title,
+			created_at
+		};
+
+		const ephemeral_block: EphemeralBlock = {
+			block_type: BlockType.EPHEMERAL,
+			label: '(nothing here yet)',
+			created_at
+		};
+
+		const page = {
+			path: new_path,
+			blocks: [title_block, ephemeral_block]
+		};
+
+		const execution_context = this.getExecutionContext();
+		const operation = new SavePageOperation(page, execution_context);
+
+		await operation.perform();
+	}
+
+	private async saveBlockToPage(): Promise<Block> {
+		const page = this.getPage();
+		const execution_context = this.getExecutionContext();
+		const block = this.getBlock();
+		const index_path = this.getIndexPath();
+		const {siblings, index} = getSiblingsAndIndexForIndexPath(page, index_path);
+
+		siblings.splice(index, 0, block);
+
+		const save_operation = new SavePageOperation(page, execution_context);
+
+		await save_operation.perform();
+
+		return block;
+	}
+
+	private getPage(): Page {
+		return this.page;
+	}
+
+	private getBlock(): Block {
+		return this.block;
+	}
+
+	private getIndexPath(): string {
+		return this.index_path;
+	}
+}
+
+export default AddBlockOperation;

package/src/server/operation/create-session.ts

@@ -0,0 +1,43 @@
+import {UnauthorizedError} from 'lib/errors';
+import ExecutionContext, {Session} from 'lib/execution-context';
+
+import BaseOperation from 'operation';
+
+class CreateSessionOperation extends BaseOperation<Session> {
+	private username: string;
+	private password: string;
+
+	public constructor(username: string, password: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.username = username;
+		this.password = password;
+	}
+
+	protected async performInternal(): Promise<Session> {
+		const {repository} = this.getConfig();
+		const username = this.getUsername();
+		const password = this.getPassword();
+		const account = await repository.getAccountForUsername(username);
+
+		if (account === undefined) {
+			throw new UnauthorizedError();
+		}
+
+		if (account.password !== password) {
+			throw new UnauthorizedError();
+		}
+
+		return repository.createSessionForAccount(account);
+	}
+
+	private getUsername(): string {
+		return this.username;
+	}
+
+	private getPassword(): string {
+		return this.password;
+	}
+}
+
+export default CreateSessionOperation;

package/src/server/operation/delete-block.ts

@@ -0,0 +1,96 @@
+import {rm} from 'fs/promises';
+
+import ExecutionContext from 'lib/execution-context';
+import {InvariantViolation, InvalidError} from 'lib/errors';
+
+import BaseOperation from 'operation';
+import FolderBlock from 'type/block/folder';
+import BlockType from 'enum/block-type';
+import Page from 'type/page';
+import Block from 'type/block';
+import LoadPageOperation from 'server/operation/load-page';
+import getFilepathForFolderBlock from 'server/utility/get-filepath-for-folder-block';
+import SavePageOperation from 'server/operation/save-page';
+import getSiblingsAndIndexForIndexPath from 'server/utility/get-siblings-and-index-for-index-path';
+
+class DeleteBlockOperation extends BaseOperation<void> {
+	private key: string;
+	private index_path: string;
+	private page: Page | undefined;
+
+	public constructor(key: string, index_path: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.key = key;
+		this.index_path = index_path;
+	}
+
+	protected async performInternal(): Promise<void> {
+		await this.loadPage();
+
+		const page = this.getPage();
+		const index_path = this.getIndexPath();
+		const {siblings, index} = getSiblingsAndIndexForIndexPath(page, index_path);
+		const [deleted_block] = siblings.splice(index, 1);
+
+		if (deleted_block === undefined) {
+			throw new InvalidError(`Unable to remove block at path ${index_path}`);
+		}
+
+		const execution_context = this.getExecutionContext();
+		const save_operation = new SavePageOperation(page, execution_context);
+
+		await save_operation.perform();
+		await this.deleteBlockArtifacts(deleted_block);
+	}
+
+	private async loadPage(): Promise<void> {
+		const key = this.getKey();
+		const execution_context = this.getExecutionContext();
+		const operation = new LoadPageOperation(key, execution_context);
+		const page = await operation.perform();
+
+		this.page = page;
+	}
+
+	private async deleteBlockArtifacts(block: Block): Promise<void> {
+		const {block_type} = block;
+
+		if (block_type !== BlockType.FOLDER) {
+			return;
+		}
+
+		const {public_directory} = this.getConfig();
+		const {path} = this.getPage();
+		const folder_block = block as FolderBlock;
+
+		const folder_path = getFilepathForFolderBlock({
+			base_path: path,
+			public_directory,
+			block: folder_block
+		});
+
+		await rm(folder_path, {
+			recursive: true,
+			force: true
+		});
+	}
+
+	private getPage(): Page {
+		if (this.page === undefined) {
+			throw new InvariantViolation('Tried to read page, but it was not set');
+		}
+
+		return this.page;
+	}
+
+	private getKey(): string {
+		return this.key;
+	}
+
+	private getIndexPath(): string {
+		return this.index_path;
+	}
+}
+
+export default DeleteBlockOperation;