feat(anni): resolve bricks & reorganize db helpers

annotation-interface/common/constants.ts

@@ -1,5 +1,6 @@
 export const supportedLanguages = ['English', 'German'] as const;
 export type SupportedLanguage = typeof supportedLanguages[number];
+export const pharMeLanguage: SupportedLanguage = 'English';
 
 export const brickUsages = [
     'Drug class',

annotation-interface/components/bricks/AutocompleteArea.tsx

@@ -5,11 +5,14 @@ import AutocompleteMenu, { AutoCompleteMenuRef } from './AutocompleteMenu';
 type Props = {
     value: string;
     onChange: (text: string) => void;
+    validPlaceholders: string[];
 };
 
-const validPlaceholders = ['drug-name', 'gene-symbol', 'gene-result'];
-
-const AutocompleteArea = ({ value: text, onChange: setText }: Props) => {
+const AutocompleteArea = ({
+    value: text,
+    onChange: setText,
+    validPlaceholders,
+}: Props) => {
     const [selection, setSelection] = useState<
         [start: number, end: number] | null
     >(null);

annotation-interface/components/bricks/BrickForm.tsx

@@ -10,11 +10,17 @@ import {
     supportedLanguages,
 } from '../../common/constants';
 import {
-    ITextBrick,
-    ITextBrickTranslation,
     translationIsValid,
     translationsToArray,
     translationsToMap,
+} from '../../database/helpers/brick-translations';
+import {
+    allBrickPlaceholders,
+    medicationBrickPlaceholders,
+} from '../../database/helpers/resolve-bricks';
+import {
+    ITextBrick,
+    ITextBrickTranslation,
 } from '../../database/models/TextBrick';
 import SelectionPopover from '../common/SelectionPopover';
 import WithIcon from '../common/WithIcon';
@@ -120,6 +126,11 @@ const BrickForm = ({ usage, brick }: Props) => {
                             onChange={(text) =>
                                 updateTranslation(language, text)
                             }
+                            validPlaceholders={
+                                usage.startsWith('Drug')
+                                    ? [...medicationBrickPlaceholders]
+                                    : [...allBrickPlaceholders]
+                            }
                         />
                     </div>
                 ))}

annotation-interface/database/helpers/brick-translations.ts

@@ -0,0 +1,29 @@
+import { SupportedLanguage } from '../../common/constants';
+import { ITextBrickTranslation } from '../models/TextBrick';
+import { OptionalId } from './types';
+
+export function translationsToMap<IdT extends OptionalId = undefined>(
+    translations: ITextBrickTranslation<IdT>[],
+): Map<SupportedLanguage, string> {
+    const map = new Map<SupportedLanguage, string>();
+    if (translations) {
+        translations.forEach((translation) =>
+            map.set(translation.language, translation.text),
+        );
+    }
+    return map;
+}
+
+export function translationsToArray(
+    translations: Map<SupportedLanguage, string>,
+): ITextBrickTranslation[] {
+    return Array.from(translations.entries()).map(([language, text]) => {
+        return { language, text };
+    });
+}
+
+export function translationIsValid<IdT extends OptionalId = undefined>(
+    translation: ITextBrickTranslation<IdT>,
+): boolean {
+    return translation.text.length > 0;
+}

annotation-interface/database/helpers/resolve-bricks.ts

@@ -0,0 +1,85 @@
+import { FilterQuery, Types } from 'mongoose';
+
+import { pharMeLanguage, SupportedLanguage } from '../../common/constants';
+import {
+    ServerGuidelineOverview,
+    ServerMedication,
+} from '../../common/server-types';
+import { IGuidelineAnnotation } from '../models/GuidelineAnnotation';
+import { IMedAnnotation } from '../models/MedAnnotation';
+import TextBrick, { ITextBrick } from '../models/TextBrick';
+import { translationsToMap } from './brick-translations';
+import { MongooseId, OptionalId } from './types';
+
+export const medicationBrickPlaceholders = ['drug-name'] as const;
+export const allBrickPlaceholders = [
+    ...medicationBrickPlaceholders,
+    'gene-symbol',
+    'gene-result',
+] as const;
+type BrickPlaceholderValues = {
+    [Property in typeof allBrickPlaceholders[number]]?: string;
+};
+
+type BrickResolver =
+    | { from: 'medAnnotation'; with: IMedAnnotation<MongooseId> }
+    | { from: 'serverMedication'; with: ServerMedication }
+    | { from: 'guidelineAnnotation'; with: IGuidelineAnnotation<MongooseId> }
+    | { from: 'serverGuideline'; with: ServerGuidelineOverview };
+
+const getPlaceholders = ({
+    from: type,
+    with: resolver,
+}: BrickResolver): BrickPlaceholderValues => {
+    switch (type) {
+        case 'medAnnotation':
+            return { 'drug-name': resolver.medicationName };
+        case 'serverMedication':
+            return { 'drug-name': resolver.name };
+        case 'guidelineAnnotation':
+            return {
+                'drug-name': resolver.medicationName,
+                'gene-symbol': resolver.geneSymbol,
+                'gene-result': resolver.geneResult,
+            };
+        case 'serverGuideline':
+            return {
+                'drug-name': resolver.medication.name,
+                'gene-symbol': resolver.phenotype.geneSymbol.name,
+                'gene-result': resolver.phenotype.geneResult.name,
+            };
+    }
+};
+
+export type ResolvedBrick<IdT extends OptionalId> = [
+    _id: IdT,
+    text: string | undefined,
+];
+
+export function resolveBricks<IdT extends OptionalId>(
+    resolver: BrickResolver,
+    bricks: ITextBrick<IdT>[],
+    language: SupportedLanguage = pharMeLanguage,
+): ResolvedBrick<IdT>[] {
+    const placeholders = getPlaceholders(resolver);
+    const resolved = bricks.map(({ _id, translations }) => {
+        let text = translationsToMap(translations).get(language);
+        if (text) {
+            Object.entries(placeholders).forEach(([placeholder, replace]) => {
+                text = text!.replaceAll(`#${placeholder}`, replace);
+            });
+        }
+        return [_id, text] as ResolvedBrick<IdT>;
+    });
+
+    return resolved;
+}
+
+export const findResolvedBricks = async (
+    resolver: BrickResolver,
+    filter: FilterQuery<ITextBrick<MongooseId>>,
+    language: SupportedLanguage = pharMeLanguage,
+): Promise<ResolvedBrick<Types.ObjectId>[]> => {
+    const bricks = await TextBrick!.find(filter).lean().exec();
+    return resolveBricks(resolver, bricks, language);
+};

annotation-interface/database/models/AbstractAnnotation.ts

@@ -1,7 +1,7 @@
 import mongoose, { SchemaValidator, Types } from 'mongoose';
 
 import { BrickUsage } from '../../common/constants';
-import { IBaseModel, OptionalId } from '../types';
+import { IBaseModel, OptionalId } from '../helpers/types';
 import TextBrick from './TextBrick';
 
 export interface IAbstractAnnotation<IdT extends OptionalId = undefined>

annotation-interface/database/models/GuidelineAnnotation.ts

@@ -1,6 +1,6 @@
 import mongoose, { Types } from 'mongoose';
 
-import { MongooseId, OptionalId } from '../types';
+import { MongooseId, OptionalId } from '../helpers/types';
 import AbstractAnnotation, {
     annotationBrickValidators,
     IAbstractAnnotation,

annotation-interface/database/models/MedAnnotation.ts

@@ -1,6 +1,6 @@
 import mongoose, { Types } from 'mongoose';
 
-import { MongooseId, OptionalId } from '../types';
+import { MongooseId, OptionalId } from '../helpers/types';
 import AbstractAnnotation, {
     annotationBrickValidators,
     IAbstractAnnotation,

annotation-interface/database/models/TextBrick.ts

@@ -6,7 +6,8 @@ import {
     BrickUsage,
     supportedLanguages,
 } from '../../common/constants';
-import { IBaseModel, OptionalId } from '../types';
+import { translationIsValid } from '../helpers/brick-translations';
+import { IBaseModel, OptionalId } from '../helpers/types';
 
 export interface ITextBrickTranslation<IdT extends OptionalId = undefined>
     extends IBaseModel<IdT> {
@@ -20,32 +21,6 @@ export interface ITextBrick<IdT extends OptionalId = undefined>
     translations: ITextBrickTranslation<IdT>[];
 }
 
-export function translationsToMap<IdT extends OptionalId = undefined>(
-    translations: ITextBrickTranslation<IdT>[],
-): Map<SupportedLanguage, string> {
-    const map = new Map<SupportedLanguage, string>();
-    if (translations) {
-        translations.forEach((translation) =>
-            map.set(translation.language, translation.text),
-        );
-    }
-    return map;
-}
-
-export function translationsToArray(
-    translations: Map<SupportedLanguage, string>,
-): ITextBrickTranslation[] {
-    return Array.from(translations.entries()).map(([language, text]) => {
-        return { language, text };
-    });
-}
-
-export function translationIsValid<IdT extends OptionalId = undefined>(
-    translation: ITextBrickTranslation<IdT>,
-): boolean {
-    return translation.text.length > 0;
-}
-
 // prevent client side from trying to use node module
 export default !mongoose.models
     ? undefined

annotation-interface/pages/api/bricks/[id].ts

@@ -1,6 +1,6 @@
 import { NextApiHandler } from 'next';
 
-import dbConnect from '../../../database/connect';
+import dbConnect from '../../../database/helpers/connect';
 import TextBrick from '../../../database/models/TextBrick';
 
 const brickApi: NextApiHandler = async (req, res) => {

annotation-interface/pages/api/bricks/index.ts

@@ -1,6 +1,6 @@
 import { NextApiHandler } from 'next';
 
-import dbConnect from '../../../database/connect';
+import dbConnect from '../../../database/helpers/connect';
 import TextBrick from '../../../database/models/TextBrick';
 
 const brickApi: NextApiHandler = async (req, res) => {

annotation-interface/pages/bricks/[id].tsx

@@ -16,7 +16,7 @@ import {
     displayCategoryForIndex,
     indexForDisplayCategory,
 } from '../../contexts/brickFilter';
-import dbConnect from '../../database/connect';
+import dbConnect from '../../database/helpers/connect';
 import TextBrick, { ITextBrick } from '../../database/models/TextBrick';
 
 const EditBrick = ({

annotation-interface/pages/bricks/index.tsx

@@ -13,7 +13,7 @@ import {
     useBrickFilterContext,
 } from '../../contexts/brickFilter';
 import { useLanguageContext } from '../../contexts/language';
-import dbConnect from '../../database/connect';
+import dbConnect from '../../database/helpers/connect';
 import TextBrick from '../../database/models/TextBrick';
 
 const AllTextBricks = ({