@fc3/mmcadi 0.1.0

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

@@ -0,0 +1,108 @@
+import {InvariantViolation} from 'lib/errors';
+
+import ExecutionContext from 'lib/execution-context';
+import getSiblingsAndIndexForIndexPath from 'server/utility/get-siblings-and-index-for-index-path';
+import parseIndexPath from 'server/utility/parse-index-path';
+import createIndexPath from 'server/utility/create-index-path';
+import BlockType from 'enum/block-type';
+import BaseOperation from 'operation';
+import LoadPageOperation from 'server/operation/load-page';
+import SavePageOperation from 'server/operation/save-page';
+import getParentIndexPath from 'server/utility/get-parent-index-path';
+
+class DemoteBlockOperation extends BaseOperation<string> {
+	private key: string;
+	private index_path: string;
+
+	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<string> {
+		const key = this.getKey();
+		const execution_context = this.getExecutionContext();
+		const load_operation = new LoadPageOperation(key, execution_context);
+		const page = await load_operation.perform();
+		const index_path = this.getIndexPath();
+		const final_path = createIndexPath([page.blocks.length - 1]);
+
+		if (index_path === final_path) {
+			return index_path;
+		}
+
+		const {
+			siblings,
+			index
+		} = getSiblingsAndIndexForIndexPath(page, index_path);
+
+		const index_parts = parseIndexPath(index_path);
+		const parent_parts = index_parts.slice(0, -1);
+
+		let new_path: string;
+
+		if (index === siblings.length - 1) {
+			const [removed_block] = siblings.splice(index, 1);
+			const parent_index_path = getParentIndexPath(index_path);
+			const {
+				siblings: parent_siblings,
+				index: parent_index
+			} = getSiblingsAndIndexForIndexPath(page, parent_index_path);
+
+			parent_siblings.splice(parent_index + 1, 0, removed_block);
+			new_path = createIndexPath([
+				...parent_parts.slice(0, -1),
+				parent_index + 1
+			]);
+		} else {
+			const new_index = index + 1;
+			const sibling = siblings[new_index];
+
+			if (sibling && sibling.block_type === BlockType.MULTI_COLUMN) {
+				const [removed_block] = siblings.splice(index, 1);
+				const children = sibling.children;
+
+				if (children === undefined) {
+					throw new InvariantViolation(`
+						Tried to read children for multi-column block,
+						but they were not set
+					`);
+				}
+
+				children.unshift(removed_block);
+				new_path = createIndexPath([
+					...parent_parts,
+					new_index,
+					0
+				]);
+			} else {
+				const [removed_block] = siblings.splice(index, 1);
+
+				new_path = createIndexPath([
+					...parent_parts,
+					new_index
+				]);
+
+				siblings.splice(new_index, 0, removed_block);
+			}
+		}
+
+		const save_operation = new SavePageOperation(page, execution_context);
+
+		await save_operation.perform();
+
+		return new_path;
+	}
+
+	private getKey(): string {
+		return this.key;
+	}
+
+	private getIndexPath(): string {
+		return this.index_path;
+	}
+}
+
+export default DemoteBlockOperation;

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

@@ -0,0 +1,26 @@
+import ExecutionContext from 'lib/execution-context';
+
+import BaseOperation from 'operation';
+
+class DestroySessionOperation extends BaseOperation<void> {
+	private session_id: string;
+
+	public constructor(session_id: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.session_id = session_id;
+	}
+
+	protected async performInternal(): Promise<void> {
+		const {repository} = this.getConfig();
+		const session_id = this.getSessionId();
+
+		await repository.destroySession(session_id);
+	}
+
+	private getSessionId(): string {
+		return this.session_id;
+	}
+}
+
+export default DestroySessionOperation;

package/src/server/operation/load-account.ts

@@ -0,0 +1,30 @@
+import Account from 'type/account';
+import BaseOperation from 'operation';
+
+class LoadAccountOperation extends BaseOperation<Account | null> {
+	protected async performInternal(): Promise<Account | null> {
+		const execution_context = this.getExecutionContext();
+		const session = execution_context.getSession();
+
+		if (session === undefined) {
+			return null;
+		}
+
+		const {username} = session;
+
+		if (username === null) {
+			return null;
+		}
+
+		const {repository} = this.getConfig();
+		const account = await repository.getAccountForUsername(username);
+
+		if (account === undefined) {
+			return null;
+		}
+
+		return account;
+	}
+}
+
+export default LoadAccountOperation;

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

@@ -0,0 +1,48 @@
+import ExecutionContext from 'lib/execution-context';
+import {NotFoundError} from 'lib/errors';
+
+import LoadPageOperation from 'server/operation/load-page';
+import getBlockAtIndexPath from 'server/utility/get-block-at-index-path';
+import Block from 'type/block';
+import BaseOperation from 'operation';
+
+class LoadBlockOperation extends BaseOperation<Block> {
+	private key: string;
+	private index_path: string;
+
+	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<Block> {
+		const key = this.getKey();
+		const execution_context = this.getExecutionContext();
+
+		const operation = new LoadPageOperation(key, execution_context);
+		const page = await operation.perform();
+
+		const index_path = this.getIndexPath();
+		const block = getBlockAtIndexPath(page, index_path);
+
+		if (block === undefined) {
+			throw new NotFoundError(`
+				Unable to find block in page ${key} at index path ${index_path}
+			`);
+		}
+
+		return block;
+	}
+
+	private getKey(): string {
+		return this.key;
+	}
+
+	private getIndexPath(): string {
+		return this.index_path;
+	}
+}
+
+export default LoadBlockOperation;

package/src/server/operation/load-directory-items.ts

@@ -0,0 +1,75 @@
+import Path from 'path';
+import {readdir, stat} from 'fs/promises';
+
+import ExecutionContext from 'lib/execution-context';
+import {getExtensionForFilepath} from 'lib/filesystem';
+
+import DirectoryItemType from 'enum/directory-item-type';
+import BaseOperation from 'operation';
+import {DirectoryItem} from 'type/block/directory';
+
+class LoadDirectoryItemsOperation extends BaseOperation<DirectoryItem[]> {
+	private path: string;
+
+	public constructor(path: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.path = path;
+	}
+
+	protected formatResult(results: DirectoryItem[]): string {
+		const filenames = results.map((directory_item) => {
+			return directory_item.filename;
+		});
+
+		return filenames.join(', ');
+	}
+
+	protected async performInternal(): Promise<DirectoryItem[]> {
+		const path = this.getPath();
+		const {public_directory} = this.getConfig();
+		const resolved_path = Path.resolve(public_directory, `.${path}`);
+		const filenames = await readdir(resolved_path);
+
+		const promises = filenames.map((filename) => {
+			const filepath = Path.resolve(resolved_path, filename);
+
+			return stat(filepath);
+		});
+
+		const combined_stats = await Promise.all(promises);
+
+		return combined_stats.map((stats, index) => {
+			const filename = filenames[index];
+
+			const item_type = (() => {
+				if (stats.isDirectory()) {
+					return DirectoryItemType.DIRECTORY;
+				}
+
+				const extension = getExtensionForFilepath(filename);
+
+				switch (extension) {
+					default:
+						return DirectoryItemType.GENERIC_FILE;
+				}
+			})();
+
+			const filesize = stats.size;
+			const created_at = Math.floor(stats.birthtimeMs);
+
+			return {
+				filename,
+				item_type,
+				filesize,
+				created_at
+			};
+		});
+	}
+
+	private getPath(): string {
+		return this.path;
+	}
+}
+
+export default LoadDirectoryItemsOperation;

package/src/server/operation/load-page.ts

@@ -0,0 +1,368 @@
+import Path from 'path';
+import {readFile} from 'fs/promises';
+
+import {StringEncoding} from 'lib/string';
+import ExecutionContext from 'lib/execution-context';
+import {exists} from 'lib/filesystem';
+import {StatusCode} from 'lib/http';
+import {
+	InvalidError,
+	NotFoundError,
+	InvariantViolation,
+	getErrorTypeForStatusCode,
+	createErrorForErrorType
+} from 'lib/errors';
+
+import BaseOperation from 'operation';
+import pathToDate from 'server/utility/path-to-date';
+import BlockType from 'enum/block-type';
+import validatePath from 'server/utility/validate-path';
+import CustomPageType from 'server/enum/custom-page-type';
+import Color from 'enum/color';
+import getWeekdayName from 'server/utility/get-weekday-name';
+import Page from 'type/page';
+import EphemeralBlock from 'type/block/ephemeral';
+import getShortOrdinal from 'server/utility/get-short-ordinal';
+import getMonthName from 'server/utility/get-month-name';
+import MultiColumnBlock from 'type/block/multi-column';
+import LinkBlock from 'type/block/link';
+import getCustomPageTypeForPath from 'server/utility/get-custom-page-type-for-path';
+import getOrdinalLabelForWeek from 'server/utility/get-ordinal-label-for-week';
+import dateToPath from 'server/utility/date-to-path';
+import getStartOfWeek from 'server/utility/get-start-of-week';
+import weekToPath from 'server/utility/week-to-path';
+import incrementDate from 'server/utility/increment-date';
+import decrementDate from 'server/utility/decrement-date';
+import dateLessThan from 'server/utility/date-less-than';
+import createDate from 'server/utility/create-date';
+import datesAreEqual from 'server/utility/dates-are-equal';
+import header from 'common/builder/block/header';
+import getCompactLabelForDate from 'server/utility/get-compact-label-for-date';
+import Emoji from 'enum/emoji';
+import validatePage from 'server/utility/validate-page';
+import Block from 'type/block';
+import ListBlock from 'type/block/list';
+
+type RawPage = Omit<Page, 'path'>;
+
+class LoadPageOperation extends BaseOperation<Page> {
+	private path: string;
+
+	public constructor(path: string, execution_context: ExecutionContext) {
+		validatePath(path);
+
+		super(execution_context);
+
+		this.path = path;
+	}
+
+	protected async performInternal(): Promise<Page> {
+		const raw_page = await this.loadRawPage();
+		const {path} = raw_page as Page;
+
+		if (path !== undefined) {
+			throw new InvariantViolation(`
+				Raw page specified an illegal path: ${path}
+			`);
+		}
+
+		const hydrated_blocks = await this.hydrateBlocks(raw_page.blocks);
+
+		const page = {
+			...raw_page,
+			blocks: hydrated_blocks,
+			path: this.getPath()
+		};
+
+		validatePage(page);
+
+		return page;
+	}
+
+	protected formatResult(result: Page): string {
+		return result.path;
+	}
+
+	private async hydrateBlocks(blocks: Block[]): Promise<Block[]> {
+		const hydrated_blocks: Block[] = [];
+
+		for (const block of blocks) {
+			const hydrated_block = await this.hydrateBlock(block);
+			hydrated_blocks.push(hydrated_block);
+		}
+
+		return hydrated_blocks;
+	}
+
+	private async hydrateBlock(block: Block): Promise<Block> {
+		if (block.block_type === BlockType.LIST) {
+			const {data_source} = block as ListBlock;
+
+			if (data_source !== undefined) {
+				const {hydrate} = this.getConfig();
+
+				if (hydrate === undefined) {
+					throw new InvalidError(`
+						Tried to hydrate a list block for data source ${data_source}
+					`);
+				}
+
+				const items = await hydrate(data_source);
+
+				block = {
+					...block,
+					items
+				} as ListBlock;
+			}
+		}
+
+		if (block.children) {
+			const hydrated_children = await this.hydrateBlocks(block.children);
+
+			block = {
+				...block,
+				children: hydrated_children
+			};
+		}
+
+		return block;
+	}
+
+	private async loadRawPage(): Promise<RawPage> {
+		const {public_directory, providers} = this.getConfig();
+		const page_path = this.getPath();
+
+		let index = 0;
+
+		const blocks: Block[] = [];
+
+		while (index < providers.length) {
+			const provider = providers[index++];
+			const {path, handler} = provider;
+
+			if (page_path === path) {
+				const subset = await handler(path);
+
+				blocks.push(...subset);
+			}
+		}
+
+		const filename = `.${page_path}/index.json`;
+		const absolute_path = Path.resolve(public_directory, filename);
+		const file_exists = await exists(absolute_path);
+
+		if (!file_exists) {
+			if (blocks.length) {
+				return {
+					blocks
+				};
+			} else if (this.shouldAutogenerate()) {
+				return this.autogenerate();
+			} else {
+				throw new NotFoundError(`Unable to find page: ${page_path}`);
+			}
+		}
+
+		const contents = await readFile(absolute_path, StringEncoding.UTF8);
+		const raw_page = JSON.parse(contents) as RawPage;
+
+		return {
+			...raw_page,
+			blocks: [
+				...raw_page.blocks,
+				...blocks
+			]
+		};
+	}
+
+	private shouldAutogenerate(): boolean {
+		const page_type = this.getCustomPageType();
+
+		switch (page_type) {
+			case CustomPageType.DATE:
+			case CustomPageType.ERROR:
+			case CustomPageType.INDEX:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	private autogenerate(): Promise<RawPage> {
+		const path = this.getPath();
+		const page_type = this.getCustomPageType();
+		const logger = this.getLogger();
+
+		logger.warn(`
+			Page not found for path ${path};
+			autogenerating as [${page_type}]...
+		`);
+
+		switch (page_type) {
+			case CustomPageType.DATE:
+				return this.autogenerateDate();
+			case CustomPageType.ERROR:
+				return this.autogenerateError();
+			case CustomPageType.INDEX:
+				return this.autogenerateIndex();
+
+			default:
+				throw new InvalidError(`Unable to autogenerate page for path: ${path}`);
+		}
+	}
+
+	private async autogenerateDate(): Promise<RawPage> {
+		const path = this.getPath();
+		const date = pathToDate(path);
+		const created_at = date.getTime();
+		const month = getMonthName(date);
+		const day = date.getUTCDate();
+		const year = date.getUTCFullYear();
+		const ordinal = getShortOrdinal(day);
+		const weekday_name = getWeekdayName(date);
+		const title = `${weekday_name}, ${month} ${ordinal}, ${year}`;
+		const execution_context = this.getExecutionContext();
+
+		const ephemeral_label = (() => {
+			const logged_in = execution_context.isLoggedIn();
+			const today = createDate();
+			const date_is_today = datesAreEqual(date, today);
+
+			if (date_is_today) {
+				if (logged_in) {
+					return `nothing here yet. post using ${Emoji.NOTEPAD} ${Emoji.MICROPHONE} ${Emoji.CAMERA}`;
+				} else {
+					return 'nothing here yet.';
+				}
+			}
+
+			const date_is_past = dateLessThan(date, today);
+
+			if (date_is_past) {
+				return 'there were no posts on this date.';
+			} else {
+				return 'this date is in the future.';
+			}
+		})();
+
+		const previous_date = decrementDate(date);
+		const previous_date_label = getCompactLabelForDate(previous_date);
+		const previous_date_path = dateToPath(previous_date);
+		const next_date = incrementDate(date);
+		const next_date_label = getCompactLabelForDate(next_date);
+		const next_date_path = dateToPath(next_date);
+		const current_week = getStartOfWeek(date);
+		const current_week_path = weekToPath(current_week);
+		const current_week_label = getOrdinalLabelForWeek(current_week);
+
+		return {
+			blocks: [
+				{
+					block_type: BlockType.LINK,
+					label: `${Emoji.UP_ARROW_UNICODE} ${current_week_label} ${Emoji.UP_ARROW_UNICODE}`,
+					href: current_week_path,
+					color: Color.BLUE,
+					created_at,
+					show_time: false
+				} as LinkBlock,
+				{
+					block_type: BlockType.MULTI_COLUMN,
+					title,
+					created_at,
+					show_time: false,
+					max_columns: 3,
+					children: [
+						{
+							block_type: BlockType.LINK,
+							label: `${Emoji.LEFT_ARROW_UNICODE} ${previous_date_label}`,
+							href: previous_date_path,
+							color: Color.BLUE,
+							created_at,
+							show_time: false
+						} as LinkBlock,
+						header(title),
+						{
+							block_type: BlockType.LINK,
+							label: `${next_date_label} ${Emoji.RIGHT_ARROW_UNICODE}`,
+							href: next_date_path,
+							color: Color.BLUE,
+							created_at,
+							show_time: false
+						} as LinkBlock
+					]
+				} as MultiColumnBlock,
+
+				{
+					block_type: BlockType.EPHEMERAL,
+					label: ephemeral_label,
+					created_at
+				} as EphemeralBlock
+			]
+		};
+	}
+
+	private async autogenerateError(): Promise<RawPage> {
+		const path = this.getPath();
+		const parsed_key = parseInt(path.slice(1));
+		const status_code = parsed_key as StatusCode;
+		const now = Date.now();
+		const error_type = getErrorTypeForStatusCode(status_code);
+		const error = createErrorForErrorType(error_type);
+
+		const title = (() => {
+			switch (status_code) {
+				case StatusCode.BAD_REQUEST:
+					return 'invalid request';
+				case StatusCode.FILE_NOT_FOUND:
+					return '404: file not found';
+				case StatusCode.UNAUTHORIZED:
+					return 'not authorized';
+				case StatusCode.SERVER_ERROR:
+					return 'something went wrong';
+
+				default:
+					return `${status_code}: ${error.message}`;
+			}
+		})();
+
+		return {
+			blocks: [
+				header(title),
+				{
+					block_type: BlockType.EPHEMERAL,
+					label: error.message,
+					created_at: now
+				} as EphemeralBlock
+			]
+		};
+	}
+
+	private async autogenerateIndex(): Promise<RawPage> {
+		const now = Date.now();
+		const {username} = this.getSession();
+
+		return {
+			blocks: [
+				header(`${username}'s home page`),
+				{
+					block_type: BlockType.EPHEMERAL,
+					label: '(nothing here yet)',
+					created_at: now
+				} as EphemeralBlock
+			]
+		};
+	}
+
+	private getCustomPageType(): CustomPageType {
+		const path = this.getPath();
+
+		return getCustomPageTypeForPath(path);
+	}
+
+	private getPath(): string {
+		return this.path;
+	}
+}
+
+export default LoadPageOperation;