Refactor for bruk av samme tjeneste til alle søk

Author: anders-nom

common/contentSearch.ts

@@ -0,0 +1,26 @@
+import { CmsContent } from './cms-documents/content';
+
+export type ContentSearchHit = Pick<
+    CmsContent,
+    'contentKey' | 'versionKey' | 'displayName' | 'path'
+> & { score: number };
+
+export type ContentSearchStatus = 'loading' | 'error' | 'success';
+
+export type ContentSearchResult = {
+    total: number;
+    params: ContentSearchParams;
+    status: ContentSearchStatus;
+    hits: ContentSearchHit[];
+};
+
+export type ContentSearchSort = 'score' | 'datetime' | 'name';
+
+export type ContentSearchParams = {
+    from: number;
+    size: number;
+    fullQuery?: boolean;
+    categoryKey?: string;
+    query?: string;
+    sort?: ContentSearchSort;
+};

common/contentSearchResult.ts

@@ -1,27 +1,22 @@
 import { CmsCategoryListItem } from '../../../common/cms-documents/category';
-import {
-    CategoryContentsResponse,
-    CmsContent,
-    CmsContentDocument,
-    CmsContentListItem,
-} from '../../../common/cms-documents/content';
-import { CmsArchiveDbClient } from '../opensearch/CmsArchiveDbClient';
+import { CmsContent, CmsContentDocument } from '../../../common/cms-documents/content';
+import { CmsArchiveOpenSearchClient } from '../opensearch/CmsArchiveOpenSearchClient';
 import { CmsBinaryDocument } from '../../../common/cms-documents/binary';
 import { CmsArchiveSiteConfig } from './CmsArchiveSite';
 import { sortVersions } from '../utils/sort';
 import { AssetDocument, CmsCategoryDocument } from '../opensearch/types';
 import { transformToCategoriesList } from './utils/transformToCategoriesList';
-import { QueryDslQueryContainer } from '@opensearch-project/opensearch/api/types';
-import { CmsCategoryRef } from '../../../common/cms-documents/_common';
-import { ContentSearchResult } from '../../../common/contentSearchResult';
+import { CmsCategoryPath } from '../../../common/cms-documents/_common';
+import { ContentSearchParams, ContentSearchResult } from '../../../common/contentSearch';
+import { buildContentSearchParams } from '../opensearch/queries/contentSearch';
 
 type ConstructorProps = {
-    client: CmsArchiveDbClient;
+    client: CmsArchiveOpenSearchClient;
     siteConfig: CmsArchiveSiteConfig;
 };
 
 export class CmsArchiveService {
-    private readonly client: CmsArchiveDbClient;
+    private readonly client: CmsArchiveOpenSearchClient;
     private readonly siteConfig: CmsArchiveSiteConfig;
 
     private readonly categoriesIndex: string;
@@ -82,114 +77,36 @@ export class CmsArchiveService {
             .then((res) => transformToCategoriesList(res, this));
     }
 
-    public async getContentsForCategory(
-        categoryKey: string,
-        from: number = 0,
-        size: number = 50,
-        query?: string
-    ): Promise<CategoryContentsResponse | null> {
-        const must: QueryDslQueryContainer[] = [
-            {
-                term: {
-                    isCurrentVersion: true,
-                },
-            },
-            {
-                term: {
-                    'category.key': categoryKey,
-                },
-            },
-        ];
-
-        if (query) {
-            must.push({
-                multi_match: {
-                    query,
-                    fields: ['displayName^10', 'xmlAsString'],
-                    type: 'phrase_prefix',
-                },
-            });
-        }
-
-        return this.client.search<CmsContentListItem>({
-            index: this.contentsIndex,
-            from,
-            size,
-            _source_includes: ['contentKey', 'versionKey', 'displayName'],
-            body: {
-                sort: {
-                    name: 'asc',
-                },
-                query: {
-                    bool: {
-                        must,
-                    },
-                },
-                track_total_hits: true,
-            },
-        });
-    }
-
-    public async contentSearch(
-        query: string,
-        from: number = 0,
-        size: number = 50
-    ): Promise<ContentSearchResult> {
+    public async contentSearch(params: ContentSearchParams): Promise<ContentSearchResult> {
         const result = await this.client.search<CmsContentDocument>({
+            ...buildContentSearchParams(params),
             index: this.contentsIndex,
-            from,
-            size,
-            _source_excludes: ['xmlAsString', 'html', 'versions'],
-            body: {
-                sort: {
-                    _score: {
-                        order: 'desc',
-                    },
-                },
-                query: {
-                    bool: {
-                        must: [
-                            {
-                                term: {
-                                    isCurrentVersion: {
-                                        value: true,
-                                    },
-                                },
-                            },
-                            {
-                                multi_match: {
-                                    query,
-                                    fields: ['displayName^10', 'xmlAsString'],
-                                    type: 'phrase_prefix',
-                                },
-                            },
-                        ],
-                    },
-                },
-            },
         });
 
         if (!result) {
             return {
-                query,
+                params,
                 total: 0,
-                error: 'Søket feilet, prøv igjen',
+                status: 'error',
                 hits: [],
             };
         }
 
+        const hits = await Promise.all(
+            result.hits.map(async (hit) => ({
+                contentKey: hit.contentKey,
+                versionKey: hit.versionKey,
+                displayName: hit.displayName,
+                score: hit._score || 0,
+                path: await this.resolveCategoryPath(hit.category.key),
+            }))
+        );
+
         return {
-            query,
+            params,
             total: result.total,
-            hits: await Promise.all(
-                result.hits.map(async (hit) => ({
-                    contentKey: hit.contentKey,
-                    versionKey: hit.versionKey,
-                    displayName: hit.displayName,
-                    score: hit._score || 0,
-                    path: await this.resolveCategoriesPath(hit.category.key),
-                }))
-            ),
+            status: 'success',
+            hits,
         };
     }
 
@@ -273,6 +190,26 @@ export class CmsArchiveService {
         return result.hits[0];
     }
 
+    async resolveCategoryPath(categoryKey: string): Promise<CmsCategoryPath> {
+        const category = await this.getCategory(categoryKey);
+        if (!category) {
+            return [];
+        }
+
+        const { key, superKey, title } = category;
+
+        const item = {
+            key,
+            name: title,
+        };
+
+        if (!superKey) {
+            return [item];
+        }
+
+        return [...(await this.resolveCategoryPath(superKey)), item];
+    }
+
     private async fixContent(
         contentDocument: CmsContentDocument | null
     ): Promise<CmsContent | null> {
@@ -284,7 +221,7 @@ export class CmsArchiveService {
             ...contentDocument,
             versions: sortVersions(contentDocument),
             html: this.fixHtml(contentDocument.html),
-            path: await this.resolveCategoriesPath(contentDocument.category.key),
+            path: await this.resolveCategoryPath(contentDocument.category.key),
         };
     }
 
@@ -297,24 +234,4 @@ export class CmsArchiveService {
             .replace(/(\r\n|\r|\n)/, '')
             .replace(/="\/(\d)+\//g, `="${this.siteConfig.basePath}/`);
     }
-
-    async resolveCategoriesPath(categoryKey: string): Promise<CmsCategoryRef[]> {
-        const category = await this.getCategory(categoryKey);
-        if (!category) {
-            return [];
-        }
-
-        const { key, superKey, title } = category;
-
-        const item = {
-            key,
-            name: title,
-        };
-
-        if (!superKey) {
-            return [item];
-        }
-
-        return [...(await this.resolveCategoriesPath(superKey)), item];
-    }
 }

server/src/cms/CmsArchiveService.ts

@@ -1,9 +1,10 @@
-import { CmsArchiveDbClient } from '../opensearch/CmsArchiveDbClient';
+import { CmsArchiveOpenSearchClient } from '../opensearch/CmsArchiveOpenSearchClient';
 import express, { Express, Response, Router } from 'express';
 import { CmsArchiveService } from './CmsArchiveService';
-import { parseNumberParam, parseQueryParamsList } from '../utils/queryParams';
+import { parseQueryParamsList } from '../utils/queryParams';
 import mime from 'mime';
 import { HtmlRenderer } from '../site/ssr/htmlRenderer';
+import { transformQueryToContentSearchParams } from '../opensearch/queries/contentSearch';
 
 export type CmsArchiveSiteConfig = {
     name: string;
@@ -14,7 +15,7 @@ export type CmsArchiveSiteConfig = {
 type ContructorProps = {
     config: CmsArchiveSiteConfig;
     expressApp: Express;
-    dbClient: CmsArchiveDbClient;
+    dbClient: CmsArchiveOpenSearchClient;
     htmlRenderer: HtmlRenderer;
 };
 
@@ -78,32 +79,13 @@ export class CmsArchiveSite {
             return res.send(contentVersion);
         });
 
-        router.get('/contentForCategory/:categoryKey', async (req, res) => {
-            const { categoryKey } = req.params;
-            const { from, size, query } = req.query;
-
-            const contentList = await this.cmsArchiveService.getContentsForCategory(
-                categoryKey,
-                parseNumberParam(from),
-                parseNumberParam(size),
-                query as string
-            );
-            if (!contentList) {
-                return res
-                    .status(404)
-                    .send(`Contents for category with key ${categoryKey} not found`);
-            }
-
-            return res.send(contentList);
-        });
-
-        router.get('/search/simple', async (req, res) => {
-            const { query } = req.query;
-            if (!query) {
-                return res.status(400).send('Parameter "query" is required');
+        router.get('/search', async (req, res) => {
+            const params = transformQueryToContentSearchParams(req);
+            if (!params) {
+                return res.status(400).send('Invalid parameters for search request');
             }
 
-            const result = await this.cmsArchiveService.contentSearch(query as string);
+            const result = await this.cmsArchiveService.contentSearch(params);
 
             return res.send(result);
         });

server/src/cms/CmsArchiveSite.ts

@@ -13,7 +13,7 @@ const transformToListItem = async (
         title,
         categories,
         contentCount: contents.length,
-        path: superKey ? await archiveService.resolveCategoriesPath(superKey) : [],
+        path: superKey ? await archiveService.resolveCategoryPath(superKey) : [],
     };
 };
 

server/src/cms/utils/transformToCategoriesList.ts

@@ -21,7 +21,7 @@ const logException = (e: unknown) => {
     }
 };
 
-export class CmsArchiveDbClient {
+export class CmsArchiveOpenSearchClient {
     private readonly openSearchClient: ClientTypeNew;
 
     constructor() {