@fc3/mmcadi 0.1.0

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

@@ -0,0 +1,104 @@
+import ExecutionContext from 'lib/execution-context';
+import {InvariantViolation} from 'lib/errors';
+
+import getSiblingsAndIndexForIndexPath from 'server/utility/get-siblings-and-index-for-index-path';
+import BaseOperation from 'operation';
+import BlockType from 'enum/block-type';
+import getParentIndexPath from 'server/utility/get-parent-index-path';
+import createIndexPath from 'server/utility/create-index-path';
+import parseIndexPath from 'server/utility/parse-index-path';
+import LoadPageOperation from 'server/operation/load-page';
+import SavePageOperation from 'server/operation/save-page';
+
+class PromoteBlockOperation extends BaseOperation<string> {
+	private page_key: string;
+	private index_path: string;
+
+	public constructor(page_key: string, index_path: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.page_key = page_key;
+		this.index_path = index_path;
+	}
+
+	protected async performInternal(): Promise<string> {
+		const page_key = this.getPageKey();
+		const execution_context = this.getExecutionContext();
+		const load_operation = new LoadPageOperation(page_key, execution_context);
+		const page = await load_operation.perform();
+		const index_path = this.getIndexPath();
+
+		if (index_path === '0') {
+			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 === 0) {
+			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, 0, removed_block);
+			new_path = parent_index_path;
+		} 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.push(removed_block);
+				new_path = createIndexPath([
+					...parent_parts,
+					new_index,
+					children.length - 1
+				]);
+			} else {
+				const [removed_block] = siblings.splice(index, 1);
+
+				index_parts.pop();
+				index_parts.push(new_index);
+				new_path = createIndexPath(index_parts);
+
+				siblings.splice(new_index, 0, removed_block);
+			}
+		}
+
+		const save_operation = new SavePageOperation(page, execution_context);
+
+		await save_operation.perform();
+
+		return new_path;
+	}
+
+	private getPageKey(): string {
+		return this.page_key;
+	}
+
+	private getIndexPath(): string {
+		return this.index_path;
+	}
+}
+
+export default PromoteBlockOperation;

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

@@ -0,0 +1,60 @@
+import Path from 'path';
+import {writeFile, mkdir} from 'fs/promises';
+
+import {StringEncoding} from 'lib/string';
+import ExecutionContext from 'lib/execution-context';
+
+import BaseOperation from 'operation';
+import Page from 'type/page';
+import BlockType from 'enum/block-type';
+import validatePage from 'server/utility/validate-page';
+
+class SavePageOperation extends BaseOperation<Page> {
+	private page: Page;
+
+	public constructor(page: Page, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.page = page;
+	}
+
+	protected async performInternal(): Promise<Page> {
+		const page = this.getPage();
+
+		validatePage(page);
+
+		const sanitized_blocks = page.blocks.filter((block) => {
+			const {block_type} = block;
+
+			return block_type !== BlockType.EPHEMERAL;
+		});
+
+		const sanitized_page = {
+			blocks: sanitized_blocks
+		};
+
+		const {public_directory} = this.getConfig();
+		const {path} = page;
+		const filepath = Path.resolve(public_directory, `./${path}/index.json`);
+		const contents = JSON.stringify(sanitized_page, null, 2);
+		const parsed_path = Path.parse(filepath);
+
+		await mkdir(parsed_path.dir, {
+			recursive: true
+		});
+
+		await writeFile(filepath, contents, StringEncoding.UTF8);
+
+		return page;
+	}
+
+	protected formatResult(result: Page): string {
+		return result.path;
+	}
+
+	private getPage(): Page {
+		return this.page;
+	}
+}
+
+export default SavePageOperation;

package/src/server/operation/update-account-settings.ts

@@ -0,0 +1,52 @@
+import {UnauthorizedError} from 'lib/errors';
+import ExecutionContext from 'lib/execution-context';
+
+import AccountSettings from 'type/account-settings';
+import BaseOperation from 'operation';
+
+class UpdateAccountSettingsOperation extends BaseOperation<AccountSettings> {
+	private settings: AccountSettings;
+
+	public constructor(settings: AccountSettings, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.settings = settings;
+	}
+
+	protected async performInternal(): Promise<AccountSettings> {
+		const execution_context = this.getExecutionContext();
+		const session = execution_context.getSession();
+
+		if (session === undefined) {
+			throw new UnauthorizedError();
+		}
+
+		const {username} = session;
+
+		if (username === null) {
+			throw new UnauthorizedError();
+		}
+
+		const {repository} = this.getConfig();
+		const account = await repository.getAccountForUsername(username);
+
+		if (account === undefined) {
+			throw new UnauthorizedError();
+		}
+
+		const settings = this.getSettings();
+
+		await repository.saveAccount({
+			...account,
+			settings
+		});
+
+		return settings;
+	}
+
+	private getSettings(): AccountSettings {
+		return this.settings;
+	}
+}
+
+export default UpdateAccountSettingsOperation;

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

@@ -0,0 +1,124 @@
+import {rename} from 'fs/promises';
+
+import {InvariantViolation} from 'lib/errors';
+import ExecutionContext from 'lib/execution-context';
+
+import Block from 'type/block';
+import BlockType from 'enum/block-type';
+import FolderBlock from 'type/block/folder';
+import getFilepathForFolderBlock from 'server/utility/get-filepath-for-folder-block';
+import BaseOperation from 'operation';
+import getSiblingsAndIndexForIndexPath from 'server/utility/get-siblings-and-index-for-index-path';
+import Page from 'type/page';
+import SavePageOperation from 'server/operation/save-page';
+import getBlockAtIndexPath from 'server/utility/get-block-at-index-path';
+
+class UpdateBlockOperation 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.sanitizeFiles();
+		await this.updateBlockArtifacts();
+
+		return this.saveBlockToPage();
+	}
+
+	private async sanitizeFiles(): Promise<void> {
+		const new_block = this.getBlock();
+		const new_files = new_block.files || [];
+		const old_block = this.getOldBlock();
+		const old_files = old_block.files || [];
+
+		if (old_files.length > 0 && new_files.length === 0) {
+			this.block = {
+				...new_block,
+				files: old_files
+			};
+		}
+	}
+
+	private async updateBlockArtifacts(): Promise<void> {
+		const new_block = this.getBlock();
+
+		if (new_block.block_type !== BlockType.FOLDER) {
+			return;
+		}
+
+		const old_block = this.getOldBlock();
+
+		if (old_block.block_type !== BlockType.FOLDER) {
+			throw new InvariantViolation(`
+				Tried to update folder block,
+				but preexisting block was of type: ${old_block.block_type}
+			`);
+		}
+
+		const {public_directory} = this.getConfig();
+		const {path} = this.getPage();
+
+		const new_folder_block = new_block as FolderBlock;
+
+		const new_path = getFilepathForFolderBlock({
+			block: new_folder_block,
+			public_directory,
+			base_path: path
+		});
+
+		const old_folder_block = old_block as FolderBlock;
+
+		const old_path = getFilepathForFolderBlock({
+			block: old_folder_block,
+			public_directory,
+			base_path: path
+		});
+
+		await rename(old_path, new_path);
+	}
+
+	private async saveBlockToPage(): Promise<Block> {
+		const page = this.getPage();
+		const execution_context = this.getExecutionContext();
+		const updated_block = this.getBlock();
+		const index_path = this.getIndexPath();
+		const {siblings, index} = getSiblingsAndIndexForIndexPath(page, index_path);
+
+		siblings.splice(index, 1, updated_block);
+
+		const save_operation = new SavePageOperation(page, execution_context);
+
+		await save_operation.perform();
+
+		return updated_block;
+	}
+
+	private getOldBlock(): Block {
+		const page = this.getPage();
+		const index_path = this.getIndexPath();
+
+		return getBlockAtIndexPath(page, index_path);
+	}
+
+	private getPage(): Page {
+		return this.page;
+	}
+
+	private getBlock(): Block {
+		return this.block;
+	}
+
+	private getIndexPath(): string {
+		return this.index_path;
+	}
+}
+
+export default UpdateBlockOperation;

package/src/server/repository/memory.ts

@@ -0,0 +1,112 @@
+import KeyGenerator from 'lib/key-generator';
+import {NotFoundError} from 'lib/errors';
+import {Session} from 'lib/execution-context';
+
+import Account from 'type/account';
+import Repository from 'interface/repository';
+
+type MemoryData = {
+	readonly accounts: Account[];
+	readonly sessions: Session[];
+}
+
+class MemoryRepository implements Repository {
+	private data: MemoryData;
+	private accounts_by_username: Record<string, Account>;
+
+	public constructor(data?: MemoryData) {
+		this.data = data || {
+			accounts: [],
+			sessions: []
+		};
+
+		this.accounts_by_username = {};
+
+		this.data.accounts.forEach((account) => {
+			const {username} = account;
+
+			this.accounts_by_username[username] = account;
+		});
+	}
+
+	public async findSession(session_id: string): Promise<Session> {
+		const session = this.data.sessions.find((session) => {
+			return session.id === session_id;
+		});
+
+		if (session === undefined) {
+			return {
+				id: session_id,
+				account_id: null,
+				username: null
+			};
+		}
+
+		return session;
+	}
+
+	public async destroySession(session_id: string): Promise<void> {
+		let found = false;
+
+		this.data = {
+			...this.data,
+			sessions: this.data.sessions.filter((session) => {
+				if (session.id === session_id) {
+					found = true;
+					return false;
+				}
+
+				return true;
+			})
+		};
+
+		if (!found) {
+			throw new NotFoundError(`Unable to find session for id: ${session_id}`);
+		}
+	}
+
+	public async createSessionForAccount(account: Account): Promise<Session> {
+		const id = KeyGenerator.generateToken();
+
+		const session = {
+			id,
+			account_id: account.id,
+			username: account.username
+		};
+
+		this.data = {
+			...this.data,
+			sessions: [
+				...this.data.sessions.filter((session) => {
+					return session.account_id !== account.id;
+				}),
+				session
+			]
+		};
+
+		return session;
+	}
+
+	public async saveAccount(new_account: Account): Promise<void> {
+		this.accounts_by_username[new_account.username] = new_account;
+
+		const accounts = this.data.accounts.map((old_account) => {
+			if (old_account.id === new_account.id) {
+				return new_account;
+			} else {
+				return old_account;
+			}
+		});
+
+		this.data = {
+			...this.data,
+			accounts
+		};
+	}
+
+	public async getAccountForUsername(username: string): Promise<Account | undefined> {
+		return this.accounts_by_username[username];
+	}
+}
+
+export default MemoryRepository;