feat: catalogs

Author: przemyslawwalczak

src/nestjs/elasticsearch.module.ts

@@ -1,5 +1,5 @@
 import { ClientOptions } from '@elastic/elasticsearch'
-import { ElasticsearchModule as BaseElasticsearchModule, ElasticsearchService as ElasticsearchBaseService } from '@nestjs/elasticsearch'
+import { ElasticsearchModule as BaseElasticsearchModule } from '@nestjs/elasticsearch'
 import { Module, DynamicModule, Provider } from '@nestjs/common'
 import { ClassConstructor } from 'lib/types'
 import { ELASTICSEARCH_CATALOG_NAME, ELASTICSEARCH_CATALOG_PREFIX } from 'lib/constants'
@@ -28,9 +28,9 @@ export class ElasticsearchModule {
             }
 
             return {
-                inject: [ElasticsearchBaseService],
+                inject: [ElasticsearchService],
                 provide: `${ELASTICSEARCH_CATALOG_PREFIX}:${name}`,
-                useFactory: (base: ElasticsearchBaseService) => new Catalog(base, document)
+                useFactory: (base: ElasticsearchService) => new Catalog(base, document)
             }
         })
 

src/nestjs/elasticsearch.service.ts

@@ -20,7 +20,7 @@ export class ElasticsearchService {
     }
 
     withCatalog<TDocument extends Document>(catalogDocument: ClassConstructor<TDocument>) {
-        return new Catalog(this.elasticsearchBaseService, catalogDocument)
+        return new Catalog(this, catalogDocument)
     }
 
     search<TDocument extends Document>(document: ClassConstructor<TDocument>, options: SearchOptions<TDocument>) {

src/nestjs/injectables/catalog.injectable.ts

@@ -1,26 +1,23 @@
 import { Injectable } from '@nestjs/common'
-import { ElasticsearchService as ElasticsearchBaseService } from '@nestjs/elasticsearch'
 import { ClassConstructor, Document, ElasticsearchCatalog } from 'lib/types'
 import { QueryBuilder } from 'lib/builders'
 import { ELASTICSEARCH_CATALOG_NAME } from 'lib/constants'
-import { ElasticsearchResult, getSearchRequest, getSearchResponse, SearchOptions } from 'lib/elasticsearch'
+import { SearchOptions } from 'lib/elasticsearch'
+import { ElasticsearchService } from '..'
 
 @Injectable()
 export class Catalog<TDocument extends Document> implements ElasticsearchCatalog<TDocument> {
     private readonly index: string
 
     constructor(
-        private readonly elasticsearchBaseService: ElasticsearchBaseService,
+        private readonly es: ElasticsearchService,
         private readonly document: ClassConstructor<TDocument>
     ) {
         this.index = Reflect.getMetadata(ELASTICSEARCH_CATALOG_NAME, document)
     }
 
     search(options: SearchOptions<TDocument>) {
-        const request = getSearchRequest<TDocument>(this.index, options)
-
-        return this.elasticsearchBaseService.search<ElasticsearchResult<TDocument>>(request)
-            .then(response => getSearchResponse(this.document, response))
+        return this.es.search(this.document, options)
             .catch(error => {
                 console.error(error)
 

src/nestjs/utils.ts

@@ -0,0 +1,3 @@
+import { ELASTICSEARCH_CATALOG_PREFIX } from 'lib/constants'
+
+export const getCatalogInjectionToken = (index: string) => `${ELASTICSEARCH_CATALOG_PREFIX}:${index}`

src/test/features/making-a-search.spec.ts renamed to src/test/features/1-making-a-search.spec.ts

@@ -0,0 +1,48 @@
+import { setupNestApplication } from 'test/toolkit'
+import { ElasticsearchModule } from 'nestjs/elasticsearch.module'
+import { HomeDocument, PropertyType } from 'test/module'
+import { getBoolQuery, getTermQuery } from 'lib/queries'
+import { validateSync } from 'class-validator'
+import { getCatalogInjectionToken } from 'nestjs/utils'
+import { Catalog } from 'nestjs/injectables'
+
+describe('Making a search', () => {
+    const { app } = setupNestApplication({
+        imports: [
+            ElasticsearchModule.register({
+                node: 'http://localhost:9200'
+            }),
+            ElasticsearchModule.forFeature([
+                HomeDocument
+            ])
+        ]
+    })
+
+    it('has catalog available', () => {
+        const catalog = app.get<Catalog<HomeDocument>>(getCatalogInjectionToken('homes'))
+
+        expect(catalog).toBeDefined()
+    })
+
+    it('makes a test search query', async () => {
+        const catalog = app.get<Catalog<HomeDocument>>(getCatalogInjectionToken('homes'))
+        const result = await catalog.search({
+            size: 10,
+            body: {
+                query: getBoolQuery({
+                    must: [
+                        getTermQuery('propertyType.keyword', PropertyType.Flat)
+                    ]
+                })
+            }
+        })
+
+        const allDocumentsAreValid = result.documents.every(document => {
+            const errors = validateSync(document)
+
+            return !errors.length
+        })
+
+        expect(allDocumentsAreValid).toBe(true)
+    })
+})