BC-6870 - Create unified board persistence entity

apps/server/src/modules/board/poc/domain/index.ts

@@ -1,4 +1,5 @@
 export * from './board-node.do';
 export * from './card.do';
+export * from './richTextElement.do';
 export * from './path-utils';
 export * from './types';

apps/server/src/modules/board/poc/domain/richTextElement.do.ts

@@ -0,0 +1,21 @@
+import { InputFormat } from '@shared/domain/types';
+import { BoardNode } from './board-node.do';
+import { RichTextElementProps } from './types';
+
+export class RichTextElement extends BoardNode<RichTextElementProps> {
+	get text(): string {
+		return this.props.text;
+	}
+
+	set text(text: string) {
+		this.props.text = text;
+	}
+
+	get inputFormat(): InputFormat {
+		return this.props.inputFormat;
+	}
+
+	set inputFormat(inputFormat: InputFormat) {
+		this.props.inputFormat = inputFormat;
+	}
+}

apps/server/src/modules/board/poc/domain/types.ts

@@ -1,8 +1,8 @@
 import { BoardNodeType } from '@shared/domain/entity';
-import { EntityId } from '@shared/domain/types';
-import type { Card } from './card.do';
+import { EntityId, InputFormat } from '@shared/domain/types';
+import type { Card, RichTextElement } from '.';
 
-export type AnyBoardNode = Card; // union type. add more types
+export type AnyBoardNode = Card | RichTextElement; // union type. add more types
 
 export interface BoardNodeProps {
 	id: EntityId;
@@ -20,4 +20,10 @@ export interface CardProps extends BoardNodeProps {
 	height: number;
 }
 
-export type AnyBoardNodeProps = CardProps; // union (or intersection?) type. add more types
+export interface RichTextElementProps extends BoardNodeProps {
+	text: string;
+	inputFormat: InputFormat;
+}
+
+export type AnyBoardNodeProps = CardProps | RichTextElementProps;
+export type AllBoardNodeProps = CardProps & RichTextElementProps;

apps/server/src/modules/board/poc/repo/board-node.repo.spec.ts

@@ -9,6 +9,7 @@ import { CardProps } from '../domain';
 import { BoardNodeEntity } from './entity/board-node.entity';
 import { BoardNodeRepo } from './board-node.repo';
 import { cardFactory } from '../testing';
+// import { Card } from '../domain/card.do';
 
 const propsFactory = Factory.define<CardProps>(({ sequence }) => {
 	return {
@@ -73,6 +74,87 @@ describe('BoardNodeRepo', () => {
 			expect(boardNode.id).toBeDefined();
 		});
 	});
+	/*
+	describe('when finding by class and id', () => {
+		describe('when the node is not of the given class', () => {
+			const setup = async () => {
+				const props = em.create(BoardNodeEntity, propsFactory.build());
+				await em.persistAndFlush(props);
+				em.clear();
+
+				return { props };
+			};
+
+			it('should throw an error', async () => {
+				const { props } = await setup();
+
+				await expect(repo.findByClassAndId(Card, props.id)).rejects.toThrowError();
+			});
+		});
+	});
+	 */
+
+	describe('when finding multiple nodes by known ids', () => {
+		const setup = async () => {
+			const props = em.create(BoardNodeEntity, propsFactory.build());
+
+			const child = cardFactory.build();
+
+			const propsWithChildren = em.create(BoardNodeEntity, propsFactory.build());
+
+			// em.find.mockResolvedValueOnce([child]);
+
+			await em.persistAndFlush([props, propsWithChildren]);
+			em.clear();
+			propsWithChildren.children = [child];
+
+			return { props, propsWithChildren, child };
+		};
+
+		it('should find the node', async () => {
+			const { props, propsWithChildren } = await setup();
+
+			const boardNodes = await repo.findByIds([props.id, propsWithChildren.id]);
+
+			expect(boardNodes[0].id).toBeDefined();
+			expect(boardNodes[1].id).toBeDefined();
+		});
+	});
+
+	describe('when finding titles by ids', () => {
+		const setup = async () => {
+			const propWithTitle = em.create(BoardNodeEntity, propsFactory.build());
+			const propWithoutTitle = em.create(BoardNodeEntity, propsFactory.build({ title: undefined }));
+			await em.persistAndFlush([propWithTitle, propWithoutTitle]);
+			em.clear();
+
+			return { propWithTitle, propWithoutTitle };
+		};
+
+		it('should find the titles', async () => {
+			const { propWithTitle, propWithoutTitle } = await setup();
+
+			const titles = await repo.getTitlesByIds([propWithTitle.id, propWithoutTitle.id]);
+
+			expect(titles[propWithTitle.id]).toEqual(propWithTitle.title);
+		});
+
+		it('should return for single id', async () => {
+			const { propWithTitle } = await setup();
+
+			const titles = await repo.getTitlesByIds(propWithTitle.id);
+
+			expect(titles[propWithTitle.id]).toEqual(propWithTitle.title);
+		});
+
+		it('should return empty string for nodes without title', async () => {
+			const { propWithoutTitle } = await setup();
+
+			const titles = await repo.getTitlesByIds(propWithoutTitle.id);
+
+			expect(titles[propWithoutTitle.id]).toEqual('');
+		});
+	});
 
 	describe('after persisting a single node', () => {
 		const setup = () => {

apps/server/src/modules/board/poc/repo/board-node.repo.ts

@@ -1,18 +1,21 @@
-import { EntityManager } from '@mikro-orm/mongodb';
-import { Injectable } from '@nestjs/common';
+import { EntityManager, ObjectId } from '@mikro-orm/mongodb';
+import { Injectable, NotFoundException } from '@nestjs/common';
 import { EntityId } from '@shared/domain/types';
-import { Utils } from '@mikro-orm/core';
+import { type FilterQuery, Utils } from '@mikro-orm/core';
+import { BoardNodeType } from '@shared/domain/entity';
+import type { BoardExternalReference } from '@shared/domain/domainobject';
 import { BoardNodeEntity } from './entity/board-node.entity';
 import { TreeBuilder } from './tree-builder';
 import { joinPath } from '../domain/path-utils';
 import { AnyBoardNode, AnyBoardNodeProps } from '../domain';
+import type { ContextExternalTool } from '../../../tool/context-external-tool/domain';
 
 @Injectable()
 export class BoardNodeRepo {
 	constructor(private readonly em: EntityManager) {}
 
-	async findById(id: EntityId, depth?: number): Promise<AnyBoardNode> {
-		const props = await this.em.findOneOrFail(BoardNodeEntity, { id });
+	public async findById(id: EntityId, depth?: number): Promise<AnyBoardNode> {
+		const props: AnyBoardNodeProps = await this.findOneOrFail(id);
 		const descendants = await this.findDescendants(props, depth);
 
 		const builder = new TreeBuilder(descendants);
@@ -21,16 +24,83 @@ export class BoardNodeRepo {
 		return boardNode;
 	}
 
-	// TODO findByIds()
+	/* TODO replace class with type instead */
+	public async findByClassAndId<S, T extends AnyBoardNode>(
+		doClass: { new (props: S): T },
+		id: EntityId,
+		depth?: number
+	): Promise<T> {
+		const domainObject = await this.findById(id, depth);
+		if (!(domainObject instanceof doClass)) {
+			throw new NotFoundException(`There is no '${doClass.name}' with this id`);
+		}
+
+		return domainObject;
+	}
+
+	// TODO: handle depth?
+	public async findByIds(ids: EntityId[]): Promise<AnyBoardNode[]> {
+		const props: AnyBoardNodeProps[] = await this.findMany(ids);
+
+		const childrenMap = await this.findDescendantsOfMany(props);
+
+		const domainObjects = props.map((prop) => {
+			const children = childrenMap[joinPath(prop.path, prop.id)];
+			const builder = new TreeBuilder(children);
+			return builder.build(prop);
+		});
+
+		return domainObjects;
+	}
+
+	public async getTitlesByIds(id: EntityId[] | EntityId): Promise<Record<EntityId, string>> {
+		const ids = Utils.asArray(id);
+		const boardNodeEntities = await this.em.find(BoardNodeEntity, { id: { $in: ids } });
+
+		const titlesMap = boardNodeEntities.reduce((map, node) => {
+			map[node.id] = node.title || '';
+			return map;
+		}, {} as Record<EntityId, string>);
+
+		return titlesMap;
+	}
 
-	persist(boardNode: AnyBoardNode | AnyBoardNode[]): BoardNodeRepo {
+	public async findByExternalReference(reference: BoardExternalReference): Promise<EntityId[]> {
+		// TODO Use an abstract base class for root nodes that have a contextId and a contextType. Multiple STI abstract base classes are blocked by MikroORM 6.1.2 (issue #3745)
+		const boardNodeEntities: BoardNodeEntity[] = await this.em.find(BoardNodeEntity, {
+			_contextId: new ObjectId(reference.id),
+			_contextType: reference.type,
+		} as FilterQuery<BoardNodeEntity>);
+
+		const ids: EntityId[] = boardNodeEntities.map((node) => node.id);
+
+		return ids;
+	}
+
+	public async countBoardUsageForExternalTools(contextExternalTools: ContextExternalTool[]) {
+		const toolIds: EntityId[] = contextExternalTools
+			.map((tool: ContextExternalTool): EntityId | undefined => tool.id)
+			.filter((id: EntityId | undefined): id is EntityId => !!id);
+
+		const boardNodeEntities = await this.em.find(BoardNodeEntity, {
+			type: BoardNodeType.EXTERNAL_TOOL,
+			contextExternalToolId: { $in: toolIds },
+		} as unknown as FilterQuery<BoardNodeEntity>);
+
+		const boardIds: EntityId[] = boardNodeEntities.map((node): EntityId => node.ancestorIds[0]);
+		const boardCount: number = new Set(boardIds).size;
+
+		return boardCount;
+	}
+
+	public persist(boardNode: AnyBoardNode | AnyBoardNode[]): BoardNodeRepo {
 		const boardNodes = Utils.asArray(boardNode);
 
 		boardNodes.forEach((bn) => {
 			let props = this.getProps(bn);
 
 			if (!(props instanceof BoardNodeEntity)) {
-				props = this.em.create(BoardNodeEntity, props);
+				props = this.em.create(BoardNodeEntity, props) as AnyBoardNodeProps;
 				this.setProps(bn, props);
 			}
 
@@ -40,24 +110,37 @@ export class BoardNodeRepo {
 		return this;
 	}
 
-	async persistAndFlush(boardNode: AnyBoardNode | AnyBoardNode[]): Promise<void> {
+	public async persistAndFlush(boardNode: AnyBoardNode | AnyBoardNode[]): Promise<void> {
 		return this.persist(boardNode).flush();
 	}
 
-	remove(boardNode: AnyBoardNode): BoardNodeRepo {
+	public remove(boardNode: AnyBoardNode): BoardNodeRepo {
 		this.em.remove(this.getProps(boardNode));
 
 		return this;
 	}
 
-	async removeAndFlush(boardNode: AnyBoardNode): Promise<void> {
+	public async removeAndFlush(boardNode: AnyBoardNode): Promise<void> {
 		await this.em.removeAndFlush(this.getProps(boardNode));
 	}
 
-	async flush(): Promise<void> {
+	public async flush(): Promise<void> {
 		return this.em.flush();
 	}
 
+	private getProps(boardNode: AnyBoardNode): AnyBoardNodeProps {
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		const { props } = boardNode;
+		return props;
+	}
+
+	private setProps(boardNode: AnyBoardNode, props: AnyBoardNodeProps): void {
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		boardNode.props = props;
+	}
+
 	private async findDescendants(props: AnyBoardNodeProps, depth?: number): Promise<AnyBoardNodeProps[]> {
 		const levelQuery = depth !== undefined ? { $gt: props.level, $lte: props.level + depth } : { $gt: props.level };
 		const pathOfChildren = joinPath(props.path, props.id);
@@ -67,17 +150,46 @@ export class BoardNodeRepo {
 			level: levelQuery,
 		});
 
-		return descendants;
+		return descendants as AnyBoardNodeProps[];
 	}
 
-	private getProps(boardNode: AnyBoardNode): AnyBoardNodeProps {
-		// @ts-ignore
-		const { props } = boardNode;
-		return props;
+	private async findDescendantsOfMany(props: AnyBoardNodeProps[]): Promise<Record<string, AnyBoardNodeProps[]>> {
+		const pathQueries = props.map((prop) => {
+			return { path: { $re: `^${joinPath(prop.path, prop.id)}` } };
+		});
+
+		const map: Record<string, AnyBoardNodeProps[]> = {};
+		if (pathQueries.length === 0) {
+			return map;
+		}
+
+		const descendants = (await this.em.find(BoardNodeEntity, {
+			$or: pathQueries,
+		})) as AnyBoardNodeProps[];
+
+		// this is for finding tha ancestors of a descendant
+		// we use this to group the descendants by ancestor
+		// TODO we probably need a more efficient way to do the grouping
+		const matchAncestors = (descendant: AnyBoardNodeProps): AnyBoardNodeProps[] => {
+			const result = props.filter((n) => descendant.path.match(`^${n.path}`));
+			return result;
+		};
+
+		for (const desc of descendants) {
+			const ancestorNodes = matchAncestors(desc);
+			ancestorNodes.forEach((node) => {
+				map[node.path] ||= [];
+				map[node.path].push(desc);
+			});
+		}
+		return map;
 	}
 
-	private setProps(boardNode: AnyBoardNode, props: AnyBoardNodeProps): void {
-		// @ts-ignore
-		boardNode.props = props;
+	private findOneOrFail(id: EntityId): Promise<AnyBoardNodeProps> {
+		return this.em.findOneOrFail(BoardNodeEntity, id) as Promise<AnyBoardNodeProps>;
+	}
+
+	private findMany(ids: EntityId[]): Promise<AnyBoardNodeProps[]> {
+		return this.em.find(BoardNodeEntity, { id: { $in: ids } }) as Promise<AnyBoardNodeProps[]>;
 	}
 }